100 Days Of Code - Web Development Bootcamp
Embark on a comprehensive journey into the world of professional software development. This course is meticulously designed to take you from a foundat...
Rating
5 /5
Enrolled
0
Community
0 Q&A
Course Objectives
Master core concepts through structured step-by-step guidance.
Build real-world projects that you can feature in your portfolio.
Understand industry-standard best practices and advanced methods.
Acquire practical skills designed to help you succeed immediately.
What You'll Learn
Understanding Containerization with Docker and Kubernetes.
Exploring Backend concurrency and multi-threading concepts.
Mastering Version Control with Git and Collaborative Workflows.
Deploying applications to cloud infrastructure with CI/CD pipelines.
Learning to write high-quality technical documentation.
Mastering CSS Preprocessors and modern styling techniques.
Developing a portfolio-ready Capstone project.
Building Real-time features with WebSockets and Socket.io.
Building scalable and maintainable software architectures from scratch.
Working with RESTful APIs and GraphQL for data management.
Optimizing application performance, latency, and memory usage.
Implementing Responsive Design principles for all screen sizes.
Developing production-ready applications with modern frameworks.
Integrating secure authentication and authorization systems.
Understanding Database Design (SQL & NoSQL) for efficient storage.
Mastering industry-standard coding practices and clean code principles.
Using professional debugging and automated testing workflows.
Learning Front-end State Management (Redux, Vuex, etc.).
Implementing advanced algorithms and complex data structures.
Course Curriculum
37 Sections • 649 Lessons • 78h 38m Total Length
001 Module Introduction [Day 1]
Locked002 How to Create a Website [Day 1]
Locked003 Creating our First HTML Page [Day 1]
Locked004 Setting Up a Development Environment [Day 2]
Locked005 Why Visual Studio Code [Day 2]
Locked006 Understanding HTML Elements [Day 2]
Locked007 Which HTML Elements Exist [Day 2]
Locked008 Adding Another HTML Element [Day 2]
Locked009 Exploring HTML Attributes [Day 2]
Locked011 Getting Started with CSS (Day 2)
Locked012 More CSS Styling [Day 2]
Locked013 colors
Locked013 Working with Colors [Day 3]
Locked014 Formatting our Code [Day 3]
Locked015 Working with the Browser Developer Tools [Day 3]
Locked016 Adding a Link [Day 3]
Locked017 You can Nest HTML Elements! [Day 3]
Locked018 Using Global CSS Styles [Day 3]
Locked020 The HTML Document Skeleton & Metadata [Day 3]
Locked021 Visual Studio Code Shortcuts & Tricks [Day 3]
Locked023 First Summary [Day 3]
Locked025 Styling the Anchor Element Also with Pseudo Hover [Day 4]
Locked026 Why it's Called Cascading Style Sheets [Day 4]
Locked027 Storing CSS Code in External Files [Day 4]
Locked028 The Void Element Syntax [Day 4]
Locked029 Multiple Files & Requests [Day 4]
Locked030 Selecting Single Elements with the ID Selector [Day 4]
Locked031 Working with font size and px [Day 4]
Locked032 Using Other Fonts from Google Fonts [Day 4]
Locked034 Adding an Image [Day 5]
Locked035 Styling the Image & Using the Body Tag [Day 5]
Locked036 Styling the Overall Page Background [Day 5]
Locked037 Adding a Second HTML File [Day 5]
Locked040 Using a Shared CSS File [Day 5]
Locked041 Organizing Source Files in Folders [Day 5]
Locked042 Summary [Day 5]
Lockedexternal links
Locked001 Module Introduction [Day 6]
Locked002 Using the Live Server Extension [Day 6]
Locked004 Understanding Lists [Day 6]
Locked005 Creating Lists [Day 6]
Locked006 Understanding Parents, Children, Containers & More [Day 6]
Locked007 Understanding Cascading, Inheritance & Specificity [Day 6]
Locked008 Styling the Full Week Page [Day 6]
Locked009 Introducing the CSS Box Model [Day 7]
Locked010 Using the CSS Box Model [Day 7]
Locked011 Creating HTML Layouts [Day 7]
Locked012 Theory Selectors & Combinators [Day 7]
Locked013 Using Selectors & Combinators [Day 7]
Locked014 Understanding Classes [Day 7]
Locked015 Block vs Inline Elements [Day 7]
Locked016 Styling Differences Between Block & Inline Elements [Day 8]
Locked017 Understanding Margin Collapsing [Day 8]
Locked018 The box shadow Property [Day 8]
Locked019 Your Challenge! [Day 8]
Locked020 Creating the HTML Layout [Day 8]
Locked021 Styling the Main Section [Day 8]
Locked022 Styling Images & Working with Negative Margins [Day 8]
Locked023 Finishing Touches [Day 8]
Locked024 Module Summary [Day 8]
Lockedexternal links
Locked001 Module Introduction [Day 9]
Locked002 Your Task! [Day 9]
Locked003 Creating the Core Structure [Day 9]
Locked004 Adding the Header Content [Day 9]
Locked005 Adding Header Styling [Day 9]
Locked006 Spacing & the CSS Box Model [Day 9]
Locked007 Adding the Main Content [Day 9]
Locked008 Styling the Main Content [Day 10]
Locked009 Styling List Items & Links [Day 10]
Locked010 Adding the Footer [Day 10]
Locked011 Introducing New HTML Elements [Day 10]
Locked012 Organizing our Files [Day 10]
Locked013 Module Summary [Day 10]
Lockedexternal links
Locked001 Module Introduction [Day 11]
Locked002 What is Hosting & Deployment [Day 11]
Locked003 Hosting a First Static Website (Example Deployment on Netlify) [Day 11]
Locked004 More Information On Netlify & HTTPS [Day 11]
Locked005 Adding a Favicon [Day 11]
Locked006 Relative vs Absolute Paths [Day 11]
Lockedexternal links
Locked001 Module Introduction [Day 11]
Locked002 What are Git & GitHub [Day 11]
Locked003 Command Line Interface (CLI) vs Graphical User Interface (GUI) [Day 11]
Locked004 Optional MacOS Terminal (z Shell) Crash Course [Day 11]
Locked005 Optional Windows Command Prompt (cmd) Crash Course [Day 12]
Locked006 Git MacOS Installation [Day 12]
Locked007 Git Windows Installation [Day 12]
Locked008 Understanding the Git Basics [Day 12]
Locked009 Initializing the Repository & Creating our First Commit [Day 12]
Locked011 Understanding Branches, Merging & Fixing Merge Conflicts [Day 13]
Locked012 Deleting Branches & Commits, Reverting Staged & Unstaged Changes [Day 13]
Locked013 Onwards to GitHub What & Why [Day 13]
Locked014 Creating a GitHub Account & a Remote Repository [Day 13]
Locked016 Understanding the Personal Access Token & git clone [Day 14]
Locked017 Collaborating on Projects Collaborators & Organizations [Day 14]
Locked018 Contributing to Projects Forks & Pull Requests [Day 14]
Locked019 Wrap Up [Day 14]
Locked001 Module Introduction [Day 15]
Locked002 Project Overview What we Will Build [Day 15]
Locked003 Project Setup [Day 15]
Locked004 Creating the Landing Page Structure [Day 15]
Locked005 Adding the Page Logo [Day 15]
Locked006 Adding the Page Navigation [Day 15]
Locked007 Introducing CSS Flexbox [Day 15]
Locked008 Aligning Flex Items [Day 15]
Locked009 Your Flexbox Challenge! [Day 16]
Locked010 Adding Flexbox to our Project [Day 16]
Locked011 Adding a Background Image [Day 16]
Locked012 Creating a Container for the Hero Content [Day 16]
Locked013 Positioning Elements [Day 16]
Locked014 Styling the Hero Content [Day 16]
Locked015 Understanding Fixed & Absolute Positioning [Day 16]
Locked016 Working with % Units & Creating a Top Navigation Bar [Day 17]
Locked017 Finishing the Header [Day 17]
Locked018 Introducing the Highlights Section [Day 17]
Locked019 Creating the HTML Code [Day 17]
Locked020 Building the Flex Container [Day 17]
Locked021 Flex Item Layout [Day 17]
Locked022 Styling Images with object fit [Day 17]
Locked023 Styling Text [Day 17]
Locked025 Understanding Parent Child Margin Collapsing [Day 18]
Locked026 Working with CSS Functions Linear Gradients [Day 18]
Locked027 The Next Step [Day 18]
Locked028 Creating a Footer Section [Day 18]
Locked029 Styling the Footer [Day 18]
Locked030 Places Page Overview & Preparations [Day 18]
Locked031 Creating the Card Content [Day 18]
Locked032 Using position static [Day 18]
Locked033 Creating the Card Look [Day 19]
Locked034 Understanding overflow & Your Challenge! [Day 19]
Locked035 Solving the Challenge [Day 19]
Locked036 Creating all Cards [Day 19]
Locked037 grid theory
Locked037 The CSS Grid Theory [Day 19]
Locked038 Understanding the nth type Selector & grid template columns [Day 19]
Locked039 Your Grid Challenge [Day 20]
Locked040 Working with Unicode UTF 8 [Day 20]
Locked041 Finishing Touches [Day 20]
Locked042 Module Summary [Day 20]
Lockedexternal links
Locked001 Module Introduction [Day 20]
Locked002 Project Overview [Day 20]
Locked004 Optional Your Challenge Creating the HTML Structure [Day 20]
Locked005 Optional Challenge Solution The HTML Structure [Day 20]
Locked006 Optional Styling the Header [Day 21]
Locked007 Optional Styling the main Section [Day 21]
Locked008 What is Responsive Design [Day 21]
Locked009 The Problem with Pixels [Day 21]
Locked010 Introducing em & rem [Day 21]
Locked011 Applying em & rem for the Font Size [Day 22]
Locked012 Deep Dive em vs rem vs % [Day 22]
Locked013 Updating the Project Units [Day 22]
Locked014 Comparing Desktop & Mobile First Design [Day 22]
Locked015 Understanding Media Queries [Day 22]
Locked016 Adding Media Queries to the Project [Day 23]
Locked017 Your Media Queries Challenge! [Day 23]
Locked018 Side Drawer & Hamburger Icon Theory [Day 23]
Locked019 Creating the Hamburger Button [Day 23]
Locked020 Creating the Side Drawer [Day 23]
Locked021 Understanding HTML Fragments [Day 23]
Locked022 Understanding the Target Selector [Day 24]
Locked023 Finishing the Side Drawer [Day 24]
Locked025 Module Summary [Day 24]
Lockedexternal links
Locked001 Module Introduction [Day 24]
Locked002 Three Things to Keep in Mind [Day 24]
Locked003 Introducing the Module Project [Day 24]
Locked004 Sizing & Spacing [Day 24]
Locked005 Choosing the Right Font [Day 24]
Locked006 Understanding The Importance of Grey, Primary & Accent Colors [Day 24]
Locked007 Introducing CSS Variables CSS Custom Properties [Day 25]
Locked008 CSS Variables in Action [Day 25]
Locked009 Comparing root vs html vs Selectors [Day 25]
Locked010 Understanding CSS Transformations [Day 25]
Locked011 Adding CSS Transitions [Day 25]
Locked012 Working with SVGs [Day 25]
Lockedexternal links
Locked001 Module Introduction [Day 26]
Locked002 What & Why [Day 26]
Locked003 Important Form HTML Elements [Day 26]
Locked004 Our First Input Element [Day 26]
Locked005 Adding a Button [Day 26]
Locked006 The Form Element, Form Submission & Different Types of Requests [Day 26]
Locked007 Styling the Form Element [Day 27]
Locked008 Adding Labels [Day 27]
Locked009 More Detailed Forms Styling [Day 27]
Locked010 Understanding Different Input Types [Day 27]
Locked011 Understanding Email, Numbers, Password & Date Types [Day 27]
Locked012 Working with Radio Buttons [Day 27]
Locked013 Using Checkboxes [Day 28]
Locked014 The Textarea Element For Longer Text [Day 28]
Locked015 Adding a Dropdown [Day 28]
Locked016 Forms & Semantics (Structuring Forms) [Day 28]
Locked017 More on Form Buttons [Day 28]
Locked018 Validation Attributes [Day 28]
Locked019 More Input & Form Attributes [Day 28]
Locked020 Your Challenge! [Day 29]
Locked021 Challenge Base Page Structure & Styling [Day 29]
Locked023 Challenge First Set of Input Elements [Day 29]
Locked024 Challenge Adding Remaining Elements [Day 29]
Locked025 Challenge Submission & Validation [Day 29]
Locked026 Challenge Styling [Day 29]
Locked001 Module Introduction [Day 29]
Locked002 What is JavaScript & Why would we use it [Day 29]
Locked003 What You Will Learn In this Module [Day 29]
Locked004 Introducing Values & Variables [Day 29]
Locked005 Adding the script HTML Element [Day 30]
Locked006 Working with Values & Basic JavaScript Commands [Day 30]
Locked007 Introducing Variables (Data Containers) [Day 30]
Locked008 A Closer Look At The JavaScript Syntax [Day 30]
Locked009 A Second Variable & Practice Time! [Day 30]
Locked010 Outsourcing JavaScript Code Into External Files [Day 30]
Locked011 Introducing Arrays (Managing Lists Of Data) [Day 30]
Locked012 Introducing Objects (Grouping Related Data) [Day 30]
Locked013 Splitting Code Across Multiple Lines [Day 31]
Locked014 Accessing Object Properties [Day 31]
Locked015 Performing Operations [Day 31]
Locked016 Onwards To Custom Commands! [Day 31]
Locked017 Introducing Functions [Day 31]
Locked018 Functions & Variables [Day 31]
Locked019 Returning Values In Functions [Day 31]
Locked020 Passing Data Into Functions With Parameters [Day 31]
Locked021 Functions A Summary [Day 31]
Locked022 Time To Practice The Problem [Day 32]
Locked023 Time To Practice The Solution [Day 32]
Locked024 Introducing Methods [Day 32]
Locked025 Making Our Developer Life Easier (Logging with console.log()) [Day 32]
Locked026 Math Operations & Working With Different Kinds Of Values [Day 32]
Locked027 The Modulus Operator [Day 32]
Locked028 Math Operations & Math Rules [Day 32]
Locked029 Performing String (Text) Operations [Day 32]
Locked030 more on operators and value types
Locked031 String Operations & String Methods [Day 32]
Locked032 Basic Array Operations [Day 33]
Locked034 Module Summary [Day 33]
Lockedexternal links
Locked001 Module Introduction [Day 33]
Locked002 Our Starting Setup [Day 33]
Locked003 The Global window & document Objects [Day 33]
Locked004 What Is The DOM [Day 33]
Locked005 Exploring The DOM [Day 33]
Locked006 Drilling Into The DOM To Select & Change HTML Elements [Day 33]
Locked007 Loading Our Script Correctly [Day 33]
Locked008 The DOM Tree & DOM Traversal [Day 33]
Locked009 Drilling Into The DOM & Exploring Text Nodes [Day 34]
Locked010 DOM Drilling Limitations [Day 34]
Locked011 Searching The DOM For Elements [Day 34]
Locked012 Querying Elements [Day 34]
Locked014 Time to Practice The Problem [Day 34]
Locked015 Time to Practice The Solution [Day 34]
Locked016 Next Steps [Day 34]
Locked017 Inserting New HTML Elements via JavaScript [Day 34]
Locked018 Deleting DOM Elements [Day 35]
Locked019 Moving Existing Elements Around [Day 35]
Locked020 Working with innerHTML [Day 35]
Locked022 Introducing Events [Day 35]
Locked023 Adding a First click Event Listener [Day 35]
Locked024 Listening To User Input Events [Day 35]
Locked025 The event Object [Day 35]
Locked027 A More Realistic Demo & Example [Day 36]
Locked028 Introducing Constant Variables (Constants) [Day 36]
Locked029 Changing Element Styles With JavaScript [Day 36]
Locked030 Managing CSS Classes With JavaScript [Day 36]
Locked031 Module Summary [Day 36]
Locked032 exercise 2
Locked032 Time to Practice The Problem [Day 37]
Locked033 Time to Practice The Solution [Day 37]
Lockedexternal links
Locked001 Module Introduction [Day 37]
Locked002 Getting Started with Control Structures [Day 37]
Locked003 Introducing Boolean Values (Booleans) & Comparison Operators [Day 37]
Locked004 Booleans & Comparison Operators In Action [Day 37]
Locked005 Using Booleans In if Statements (Conditional Code Execution) [Day 37]
Locked006 A Real Example [Day 38]
Locked007 Alternatives with else and else if [Day 38]
Locked008 More on Boolean Values [Day 38]
Locked009 Truthy & Falsy Values [Day 38]
Locked011 Introducing Loops (Repeated Code Execution) [Day 38]
Locked012 The Regular for Loop [Day 38]
Locked013 The for of Loop (for Arrays) [Day 38]
Locked015 The for in Loop (for Objects) [Day 38]
Locked016 The while Loop [Day 38]
Locked017 09 practice time starting setup
Locked017 Practice Time Setup & The for Loop [Day 39]
Locked018 Practice Time The for of Loop [Day 39]
Locked019 Practice Time The for in Loop [Day 39]
Locked020 Practice Time The while Loop [Day 39]
Locked021 Module Summary [Day 39]
Lockedexternal links
Locked001 Module Introduction [Day 40]
Locked002 Planning The Project [Day 40]
Locked003 Creating The HTML Structure [Day 40]
Locked004 Adding Base Page Styles [Day 40]
Locked005 Adding Styling For The Game Configuration Area [Day 41]
Locked006 Styling The Game Board [Day 41]
Locked007 Adding JavaScript, Script Files & First Event Listeners [Day 41]
Locked008 Showing & Hiding The Configuration Modal (Overlay) [Day 41]
Locked009 Handling Form Submission With JavaScript [Day 42]
Locked010 Validating User Input With JavaScript [Day 42]
Locked011 Storing & Managing Submitted Data [Day 42]
Locked012 Adding Logic For Starting A Game [Day 43]
Locked013 Managing Game Rounds (Turns) & Field Selection [Day 43]
Locked014 Tracking Selected Fields On The Game Board [Day 43]
Locked015 Checking For A Winner Or Draw [Day 44]
Locked016 Ending The Game & Adding Restart Logic [Day 44]
Locked017 Module Summary [Day 44]
Lockedexternal links
Locked001 Module Introduction [Day 45]
Locked002 What & Why [Day 45]
Locked003 Third Party Code vs Custom Code (Your Own Code) [Day 45]
Locked004 First Example Adding Bootstrap For Some Default Styling [Day 45]
Locked005 Adding & Using the Bootstrap CSS Package [Day 45]
Locked006 Adding a JavaScript Package [Day 45]
Locked007 Adding an Image Carousel Gallery with a Third Party Package [Day 45]
Locked007 images
Locked008 Combining Third Party Packages With Custom Code [Day 45]
Locked009 More Bootstrap Examples [Day 45]
Locked010 Exercise Solution & First Summary [Day 45]
Locked011 Another Example Preparing a Parallax Page [Day 45]
Locked012 Adding A Parallax Effect Package [Day 46]
Locked013 Viewing Third Party Source Code & Module Summary [Day 46]
Locked001 Module Introduction [Day 46]
Locked002 What is The Backend & Why Do We Need Server side Code [Day 46]
Locked004 Frontend vs Backend vs Fullstack Development [Day 46]
Locked005 Choosing a Backend (Server side) Programming Language [Day 46]
Locked002 Installing NodeJS [Day 47]
Locked003 Executing NodeJS Code [Day 47]
Locked004 Creating a Custom NodeJS Server [Day 47]
Locked005 Handling Requests & Creating Custom Responses [Day 47]
Locked006 Doing More Server side Work [Day 47]
Locked008 Summary [Day 47]
Lockedexternal links
Locked001 Module Introduction [Day 48]
Locked002 Installing Express with npm [Day 48]
Locked003 Creating a Server with Express & Handling Requests + Responses [Day 48]
Locked004 Parsing User Data With Express [Day 48]
Locked005 Storing Data in (Server side) Files [Day 48]
Locked007 Reading File Data & Returning Dynamic Responses (Dynamic HTML Code) [Day 49]
Locked008 Enhancing the Developer Workflow with nodemon [Day 49]
Locked009 Summary [Day 49]
Locked001 Module Introduction [Day 49]
Locked002 Creating a Starting Project & What Needs To Change [Day 49]
Locked003 Setting Up A Basic Express App (incl. Practice) [Day 49]
Locked004 Serving HTML Files With Node & Express [Day 49]
Locked005 Serving Static Files (CSS & JavaScript) [Day 50]
Locked006 Parsing Form Data & Redirecting Requests [Day 50]
Locked007 Adding the EJS Template Engine [Day 50]
Locked008 Rendering Dynamic Content With Templates [Day 50]
Locked009 Outputting Repeated Content With EJS & Loops [Day 50]
Locked010 Rendering Conditional Content [Day 50]
Locked011 Including Partial Content [Day 51]
Locked012 EJS & IDE Support [Day 51]
Locked013 Module Summary [Day 51]
Lockedexternal links
Locked001 Module Introduction [Day 51]
Locked002 Introducing Dynamic Routes [Day 51]
Locked003 Managing Data with Unique IDs [Day 51]
Locked004 Loading & Displaying Detail Data [Day 52]
Locked005 Showing a 404 Page For Not Found Cases [Day 52]
Locked006 More 404 Page Usage (Non Existent Routes) [Day 52]
Locked007 Handling Server Side Errors (500 Status Code) [Day 52]
Locked008 Working With Status Codes [Day 52]
Locked009 Code Refactoring & Adding More Functions [Day 52]
Locked010 Importing & Exporting Code In NodeJS [Day 53]
Locked011 Using The Express Router To Split The Route Configuration [Day 53]
Locked012 Introducing Query Parameters (& Hidden Form Fields) [Day 53]
Locked014 Module Summary [Day 53]
Lockedexternal links
Locked001 Module Introduction [Day 54]
Locked002 Functions & Default Parameters [Day 54]
Locked003 Rest Parameters & The Spread Operator [Day 54]
Locked004 Functions Are Objects! [Day 54]
Locked005 Working with Template Literals [Day 54]
Locked006 Primitive vs Reference Values [Day 54]
Locked007 Custom Error Handling With try catch [Day 55]
Locked009 Variable Scoping & Shadowing [Day 55]
Locked011 Introducing Classes As Object Blueprints [Day 55]
Locked012 Classes & Methods (and this) [Day 55]
Locked013 Destructuring Objects & Arrays [Day 55]
Locked015 Diving Into Asynchronous Code & Callback Functions [Day 56]
Locked016 Introducing Promises [Day 56]
Locked017 Asynchronous Code & Error Handling [Day 56]
Locked018 Improving Code With async await [Day 56]
Locked020 Module Summary [Day 56]
Locked020 more advanced javascript
Locked001 Module Introduction [Day 56]
Locked002 Why Databases And What Are Databases In The First Place [Day 56]
Locked003 A Quick Introduction To SQL Databases (RDBMS) [Day 57]
Locked004 A Quick Introduction To NoSQL Databases [Day 57]
Locked005 SQL vs NoSQL Databases [Day 57]
Locked001 Module Introduction [Day 57]
Locked002 What & Why [Day 57]
Locked003 RDBMS Options [Day 57]
Locked004 Installing MySQL & Setup Steps [Day 57]
Locked005 Database Server vs Databases vs Tables [Day 57]
Locked006 Writing Our First SQL Code & Creating a Database [Day 57]
Locked007 Creating a Table & Table Structure [Day 58]
Locked008 Inserting Data Into A Table [Day 58]
Locked009 Reading Data From A Table (incl. Filtering) [Day 58]
Locked010 Updating & Deleting Data [Day 58]
Locked011 Designing A More Complex Database [Day 58]
Locked012 Adding A New Table [Day 58]
Locked013 Implementing A More Complex Design With Relations [Day 59]
Locked014 Inserting Related Data [Day 59]
Locked015 Practice Inserting Related Data [Day 59]
Locked016 Querying & Joining Related Data [Day 59]
Locked017 Practice Joining Data [Day 59]
Locked018 Module Summary & More On Relationships [Day 59]
Locked001 Module Introduction [Day 60]
Locked002 Why Should Database Accessing Code Run On The Backend [Day 60]
Locked003 What We'll Build In This Section [Day 60]
Locked004 Planning Our Database Structure [Day 60]
Locked005 Database Initialization [Day 60]
Locked006 00 starting project
Locked006 Project Setup [Day 60]
Locked007 Creating Our First Routes [Day 60]
Locked008 Connecting To The Database & Querying Data [Day 61]
Locked009 Inserting Data With Placeholders (Injecting Dynamic Data) [Day 61]
Locked010 Fetching & Displaying a List Of Blog Posts [Day 61]
Locked011 Fetching & Displaying a Single Blog Post [Day 62]
Locked012 Formatting & Transforming Fetched Data [Day 62]
Locked013 Preparing The Update Post Page [Day 62]
Locked014 Updating Posts [Day 62]
Locked015 Deleting Posts [Day 62]
Locked016 Module Summary [Day 62]
Locked001 Module Introduction [Day 63]
Locked002 The Idea Behind NoSQL Database Systems [Day 63]
Locked003 Introducing MongoDB [Day 63]
Locked004 General Setup Instructions & Installing MongoDB on macOS [Day 63]
Locked005 Installing MongoDB on Windows [Day 63]
Locked006 Installing the MongoDB Shell [Day 63]
Locked007 Inserting Data with MongoDB [Day 63]
Locked008 Reading & Filtering Data [Day 64]
Locked009 Updating Documents In A MongoDB Database [Day 64]
Locked010 Deleting Documents With MongoDB [Day 64]
Locked011 Planning a Complete Database Design Layout [Day 64]
Locked012 Implementing the Planned Design & Layout [Day 64]
Locked013 Practice Time & More Filtering Operators [Day 64]
Locked001 Module Introduction [Day 65]
Locked002 Planning the Database Structure & Layout [Day 65]
Locked003 00 starting project
Locked003 Project & Database Initialization [Day 65]
Locked005 Connecting to MongoDB (from inside NodeJS) [Day 65]
Locked006 Fetching & Displaying A List Of Authors [Day 65]
Locked007 Inserting Documents (New Posts) [Day 65]
Locked008 Fetching & Displaying Documents [Day 66]
Locked010 Fetching a Single Document [Day 66]
Locked011 Transforming & Preparing Data [Day 66]
Locked012 Updating Documents [Day 66]
Locked013 Deleting Documents [Day 66]
Locked014 ExpressJS & Handling Asynchronous Code Errors [Day 67]
Locked001 Module Introduction [Day 67]
Locked002 00 starting project
Locked002 The Two Sides Of Uploading Files & Setting Up A Starting Project [Day 67]
Locked003 Adding A File Picker To A Form [Day 67]
Locked004 Parsing Incoming File Uploads With The multer Package [Day 67]
Locked005 How To Store Files On A Backend [Day 67]
Locked006 Configuring Multer In Depth [Day 67]
Locked007 Storing File Data In A Database (And What NOT To Store) [Day 68]
Locked008 Serving Uploaded Files To Website Visitors [Day 68]
Locked009 Adding An Image Preview Feature [Day 68]
Locked010 Module Summary [Day 68]
Locked001 Module Introduction [Day 68]
Locked002 What Is Ajax And Why Would We Need It [Day 68]
Locked003 What is Ajax [Day 68]
Locked004 00 starting project
Locked004 The Starting Project & A Problem [Day 69]
Locked005 Sending & Handling a GET Ajax Request [Day 69]
Locked006 Updating The DOM Based On The Response [Day 69]
Locked007 Preparing The POST Request Data [Day 69]
Locked008 Sending & Handling a POST Ajax Request [Day 69]
Locked009 Improving The User Experience (UX) [Day 70]
Locked010 Handling Errors (Server side & Technical) [Day 70]
Locked011 We Now Have More HTTP Methods! [Day 70]
Locked012 Module Summary [Day 70]
Locked001 Module Introduction [Day 70]
Locked002 What is Authentication & Why Would You Want To Add It To A Website [Day 70]
Locked003 00 starting project
Locked003 Our Starting Project [Day 70]
Locked004 Adding a Basic Signup Functionality [Day 70]
Locked005 Must Do Hashing Passwords [Day 71]
Locked006 Adding User Login Functionality [Day 71]
Locked007 Validating Signup Information [Day 71]
Locked008 Introducing Sessions & Cookies The Stars Of Authentication [Day 71]
Locked009 Adding Sessions Support To Our Website [Day 71]
Locked010 Storing Authentication Data In Sessions [Day 72]
Locked012 Using Sessions & Cookies For Controlling Access [Day 72]
Locked013 Adding The Logout Functionality [Day 72]
Locked014 A Closer Look At Cookies [Day 72]
Locked015 Diving Deeper Into Sessions (Beyond Authentication) [Day 72]
Locked017 Authorization vs Authentication [Day 73]
Locked018 Practicing Sessions & Working With Sessions [Day 73]
Locked019 Writing Custom Middlewares & Using res.locals [Day 73]
Locked020 Module Summary [Day 73]
Locked001 Module Introduction [Day 74]
Locked002 Authentication vs Website Security [Day 74]
Locked003 00 starting projects
Locked003 Understanding CSRF Attacks [Day 74]
Locked004 Partial CSRF Protection With Same Site Cookies [Day 74]
Locked005 Implementing A Better CSRF Protection [Day 74]
Locked007 Understanding XSS Attacks [Day 74]
Locked008 Protecting Against XSS Attacks [Day 74]
Locked009 Understanding SQL Injection Attacks [Day 75]
Locked010 Protecting Against SQL Injection Attacks [Day 75]
Locked011 A Word About NoSQL Injection [Day 75]
Locked012 Module Summary [Day 75]
Locked013 Avoid Exposing Your Server side Code or Data Accidentally! [Day 75]
Locked001 Module Introduction [Day 75]
Locked002 00 starting project
Locked002 Our Starting Project (Deep Dive) [Day 75]
Locked003 What's Wrong With Our Code [Day 75]
Locked004 Splitting Our Routes [Day 76]
Locked005 Extracting Configuration Settings [Day 76]
Locked006 Extracting Custom Middleware [Day 76]
Locked007 An Introduction To The MVC Pattern [Day 76]
Locked008 Creating Our First Model [Day 76]
Locked009 Adding Update & Delete Functionalities To The Model [Day 76]
Locked010 Adding Fetch Functionalities To The Model [Day 76]
Locked011 Adding A First Controller & Controller Actions [Day 77]
Locked012 Refactoring The Sessions & Input Validation Errors Functionality [Day 77]
Locked013 Refactoring The CSRF Token Handling [Day 77]
Locked014 Migrating The Authentication Functionality To MVC [Day 77]
Locked015 Improving Asynchronous Error Handling [Day 78]
Locked016 Protecting Routes With Custom Middleware [Day 78]
Locked001 Module Introduction [Day 78]
Locked002 Planning The Project [Day 78]
Locked003 Your Challenge! [Day 78]
Locked004 Course Project Setup [Day 78]
Locked005 Creating Folders, Files & A First Set Of Routes [Day 78]
Locked006 Adding EJS & First Views [Day 79]
Locked007 Populating & Rendering The First View [Day 79]
Locked008 Adding Base CSS Files & Static File Serving [Day 79]
Locked009 Adding CSS Variables & A Website Theme [Day 79]
Locked010 More Base CSS Styles For The Website [Day 80]
Locked011 Styling First Form Elements [Day 80]
Locked012 Adding A MongoDB Database Server & Connection [Day 80]
Locked013 Adding User Signup [Day 81]
Locked014 Security Time Adding CSRF Protection [Day 81]
Locked015 Implementing Proper Error Handling With The Error Handling Middleware [Day 81]
Locked016 Introducing Sessions & Configuring Sessions [Day 81]
Locked017 Implementing Authentication & User Login [Day 82]
Locked018 Finishing Authentication & Checking The Auth Status (Custom Middleware) [Day 82]
Locked019 Adding Logout Functionality [Day 82]
Locked020 Handling Errors In Asynchronous Code [Day 82]
Locked021 Adding User Input Validation [Day 82]
Locked022 Flashing Errors & Input Data Onto Sessions [Day 83]
Locked023 Displaying Error Messages & Saving User Input [Day 83]
Locked024 Admin Authorization & Protected Navigation [Day 83]
Locked025 Setting Up Base Navigation Styles [Day 83]
Locked026 Building a Responsive Website [Day 84]
Locked027 Frontend JavaScript For Toggling The Mobile Menu [Day 84]
Locked028 Adding Product Admin Pages & Forms [Day 84]
Locked029 Adding The Image Upload Functionality [Day 85]
Locked030 More Data Adding a Product Model & Storing Products In The Database [Day 85]
Locked031 Fetching & Outputting Product Items [Day 85]
Locked032 Styling Product Items [Day 86]
Locked033 Adding the Product Details (Single Product) Page [Day 86]
Locked034 Updating Products (As Administrator) [Day 86]
Locked035 Adding a File Upload Preview [Day 87]
Locked036 Making Products Deletable [Day 87]
Locked037 Using Ajax Frontend JS Requests & Updating The DOM [Day 87]
Locked038 Various Fixes & Proper Route Protection [Day 88]
Locked039 Outputting Products For Customers [Day 88]
Locked040 Outputting Product Details [Day 88]
Locked041 Adding A Cart Model [Day 89]
Locked042 Working On The Shopping Cart Logic [Day 89]
Locked043 Adding Cart Items Via Ajax Requests [Day 89]
Locked044 Adding A Cart Page [Day 90]
Locked045 Styling The Cart Page [Day 90]
Locked046 Updating Cart Items (Changing Quantities) [Day 90]
Locked047 Updating Carts Via Ajax Requests (PATCH Requests) [Day 90]
Locked048 Updating The DOM After Cart Item Updates [Day 91]
Locked050 Adding The Order Controller & A Basic Order Model [Day 91]
Locked051 Saving Orders In The Database [Day 91]
Locked052 Displaying Orders (For Customers & Administrators) [Day 92]
Locked053 Managing Orders As An Administrator [Day 92]
Locked054 Keeping Cart Items Updated [Day 92]
Locked055 Bugfixing & Polishing [Day 92]
Locked056 Module Summary [Day 92]
Lockedexternal links
Locked001 Module Introduction [Day 93]
Locked002 What Are Services & APIs [Day 93]
Locked003 Why Would You Use Services & APIs [Day 93]
Locked004 Introducing Stripe [Day 93]
Locked005 Creating A Stripe Account [Day 93]
Locked006 Setting Up A Stripe API Request [Day 93]
Locked007 Configuring The Stripe Request & Handling Payments [Day 93]
Locked008 Module Summary [Day 93]
Lockedexternal links
Locked001 Module Introduction [Day 94]
Locked002 How Are Websites Made Available To The Public [Day 94]
Locked003 Static vs Dynamic Websites [Day 94]
Locked004 Hosting Database Servers [Day 94]
Locked005 Deployment (Preparation) Steps [Day 94]
Locked006 00 starting projects
Locked006 The Example Projects [Day 94]
Locked007 Testing & Code Preparation (incl. Environment Variables) [Day 94]
Locked008 Evaluating Cross Browser Support [Day 94]
Locked009 Search Engine Optimization (SEO) [Day 94]
Locked011 Improving Performance & Shrinking Assets (JS, Images) [Day 95]
Locked012 Deployment Example Static Websites (Refresher) [Day 95]
Locked013 Deployment Example Dynamic Website With Backend Code [Day 95]
Locked014 Deploying A MongoDB Database With Atlas [Day 95]
Locked015 Finishing Dynamic Website Deployment [Day 95]
Locked001 Module Introduction [Day 95]
Locked002 APIs & Services What & Why [Day 95]
Locked003 JS Packages vs URL based APIs What We Will Build Here [Day 95]
Locked004 APIs vs Traditional Websites [Day 95]
Locked005 Introducing REST APIs [Day 96]
Locked006 Building A First Basic REST API [Day 96]
Locked007 Enhancing The API & Making It More Realistic [Day 96]
Locked008 03 more complex api starting snapshot
Locked008 A More Complex REST API First Steps [Day 96]
Locked009 Finishing The First API Endpoints [Day 97]
Locked010 Testing APIs With Postman [Day 97]
Locked011 Adding PATCH & DELETE Routes Endpoints [Day 97]
Locked012 06 adding a decoupled frontend
Locked012 Adding A Decoupled Frontend Website (SPA) [Day 97]
Locked013 Why Would You Use A Decoupled Frontend SPA [Day 97]
Locked014 Understanding CORS Errors [Day 97]
Locked015 Fixing CORS Errors & Connecting The Frontend SPA To The REST API [Day 97]
Lockedexternal links
Locked001 Module Introduction [Day 98]
Locked002 Why Would You Use Frontend JavaScript UI Frameworks [Day 98]
Locked003 React vs Vue vs Angular Which Framework Should You Use [Day 98]
Locked004 06 adding a decoupled frontend
Locked004 Getting Started With Vue.js (Vue) [Day 98]
Locked005 Listening To Events & Updating Data + the DOM [Day 98]
Locked006 Introducing Two Way Binding [Day 98]
Locked007 Outputting Lists Of Data [Day 99]
Locked008 Outputting Content Conditionally [Day 99]
Locked009 Updating Data [Day 99]
Locked010 Deleting Data [Day 99]
Locked011 Sending a POST Http Request [Day 99]
Locked012 Loading Data & Managing Loading States [Day 99]
Locked013 Loading Vue Differently [Day 99]
Locked014 Sending PATCH + DELETE Requests & Module Summary [Day 99]
Locked001 Bonus Possible Next Steps, Practice Opportunities & Project Ideas [Day 100]
Lockedexternal links
LockedCourse Description
Why This Course is Different
• Deep dive into modern architectural patterns and best practices.
• Hands-on experience with the latest industry frameworks and tools.
• Portfolio-focused projects that demonstrate your engineering capabilities.
• Guidance on passing technical interviews and landing your dream job.
A Comprehensive Learning Journey
From the very first module, you'll be immersed in practical, hands-on activities designed to bridge the gap between knowledge and action. We cover everything from foundational principles to advanced techniques that even many industry veterans overlook. By the end of this course, you won't just 'know' the subject; you will have the confidence and the evidence (through your projects) to prove your mastery to yourself and to the world at large. Welcome to the elite level of performance.
Requirements
- Familiarity with command-line tools is helpful but not required.
- Motivation to practice coding daily and solve problems.
- A computer (Mac, PC, or Linux) with administrative access.
- Basic understanding of programming logic and syntax.
- Standard internet connection for downloading packages.
Target Audience
- Self-taught programmers wanting to solidify their knowledge.
- Aspiring developers looking to enter the tech industry.
- Computer science students seeking practical, real-world skills.
Feedback Reviews
Course Price
This Course Includes:
Secure Payment Processing: SSL-AES256
Secured
Eternal
Flash
Total Price