Upcoming Releases

Ever wondered how to persist data without setting up a full database? In this episode, we explore file-based storage in Node.js — a simple way to read, write, and manage data using the filesystem.

Perfect for small projects, prototypes, or when you just need to get things done quickly ⚙️💾

👉 You’ll learn how to:
- Read and write JSON files asynchronously using fs/promises
- Implement full CRUD (Create, Read, Update, Delete) operations
- Handle data safely and understand file-based storage limitations
- Prepare your app for a transition to a real database later


💡 Relevant Links
Node.js Docs:
- Reading Files: https://nodejs.org/en/learn/manipulating-files/reading-files-with-nodejs
- Writing Files: https://nodejs.org/en/learn/manipulating-files/writing-files-with-nodejs

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

It’s time to level up from file-based storage! In this episode, we explore why databases exist, how they solve key scalability problems, and how to use SQLite to manage structured data in Node.js.

💥 You’ll see how to:
👉 Compare file-based vs. database storage
👉 Understand relational vs. document databases
👉 Install and use SQLite in Node.js
👉 Implement full CRUD operations (Create, Read, Update, Delete)
👉 Explore when to choose SQLite, PostgreSQL, or MongoDB

💡 Relevant Links

- SQLite official: https://www.sqlite.org/index.html
- SQLite Node: https://www.npmjs.com/package/sqlite3
- PostgreSQL official: https://www.postgresql.org/
- MongoDB official: https://www.mongodb.com/


Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Static HTML can only take you so far. In this episode, we explore why Server-Side Rendering (SSR) and templates are essential for building dynamic web applications.

We’ll look at how to generate HTML dynamically using JavaScript, what makes manual templating so painful, and why templating engines like EJS are the next logical step.


💡 You’ll Learn

- The difference between Static HTML and Server-Side Rendering (SSR)
- Benefits of dynamic content in web apps
- How to manually render HTML from JavaScript data
- The drawbacks of manual templating
- Why separating data from layout improves maintainability


💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Resources mentioned:
- Node.js: https://nodejs.org
- TailwindCSS: https://tailwindcss.com
- PrismJS: https://prismjs.com

EJS (Embedded JavaScript) is one of the simplest ways to generate dynamic HTML on the server — without the chaos of string concatenation. 💡

In this episode, we’ll walk through how to:
✅ Install and configure EJS in a Node.js project
✅ Embed JavaScript directly inside HTML templates
✅ Use loops and conditionals for dynamic content
✅ Render full pages from data
✅ Create reusable layouts and partials for cleaner structure

By the end, you’ll know how to serve fully rendered HTML from your Node.js server using EJS — the perfect first step toward clean, maintainable server-side rendering (SSR).

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Official Docs & Resources:
- EJS Docs: https://ejs.co/
- Node.js Documentation: https://nodejs.org/en/docs/
- MDN JavaScript Guide: https://developer.mozilla.org/en-US/docs/Web/JavaScript

In this episode, we take our server-side JavaScript app to the next level by introducing a minimal MVC (Model-View-Controller) structure.

You’ll learn how to organize your code so that:

- Models manage your data and logic
- Views handle presentation using EJS templates
- Controllers direct traffic and keep your routes clean

This structured approach transforms your growing project into something that feels modular, scalable, and professional — all without frameworks.


💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Official Docs & Resources:
- EJS Docs: https://ejs.co/
- Node.js Documentation: https://nodejs.org/en/docs/
- MDN JavaScript Guide: https://developer.mozilla.org/en-US/docs/Web/JavaScript
- MVC Pattern (MDN): https://developer.mozilla.org/en-US/docs/Glossary/MVC

Your MVC framework is about to come alive ⚡️

So far, we’ve built the parts — now it’s time to see them in motion. In this episode, we’ll trace how every request flows through your application — from the moment it hits the server to the controller logic that shapes the response. 🌐

👉 In this episode, you’ll learn how to:

🚀 Follow the full request/response lifecycle in an MVC app
⚙️ Understand how routing, controllers, and views work together
📦 Parse request bodies and extract parameters dynamically
🧩 Connect the dots between HTTP, Router, and Controller layers

By the end, you’ll see your framework as a living, breathing system — where every part plays its role in delivering dynamic web pages 💻

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Official Docs & Resources:
- Node.js Documentation: https://nodejs.org/en/docs/
- MDN HTTP Guide: https://developer.mozilla.org/en-US/docs/Web/HTTP
- MDN JavaScript Guide: https://developer.mozilla.org/en-US/docs/Web/JavaScript

Your web app just got personal 💬

Until now, your MVC app could display and fetch data — but it couldn’t accept new information from users. That changes today.

👉 In this episode, you’ll learn how to:
🧠 Handle HTML forms and capture user input
⚙️ Parse incoming POST data in Node.js
✅ Add server-side validation for required fields, length, and patterns
🧹 Understand the difference between validation (checking data) and sanitization (cleaning data)
📄 Build your own simple validation rules and validator utility

By the end, your app will safely handle real user input — a huge step toward full interactivity ⚡️

💡 Relevant Links

Previous TekCasts series:
• JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
• JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Official Docs & Resources:
• MDN HTML Forms Guide: https://developer.mozilla.org/en-US/docs/Learn/Forms
• MDN Client-Side Form Validation: https://developer.mozilla.org/en-US/docs/Learn/Forms/Form_validation
• Node.js Streams: https://nodejs.org/api/stream.html
• Node.js HTTP Module: https://nodejs.org/api/http.html
• EJS Documentation: https://ejs.co/

HTTP is stateless — every request is brand new.
So… how do we remember users, personalize experiences, or keep them logged in?

That’s where cookies come in 🍪✨

👉 In this episode, you’ll learn how to:

🚀 Read and parse cookie data from incoming requests
⚙️ Set and clear cookies from your server responses
🔐 Understand cookie flags like HttpOnly, Max-Age, and Path
🧠 Explore real-world uses like sessions, personalization, and analytics

By the end, you’ll have a working mental model of how state travels between client and server — and how cookies form the foundation of sessions and authentication in modern web apps.

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Official Docs & Resources:
- MDN: HTTP Cookies — https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies
- Node.js HTTP Module — https://nodejs.org/api/http.html
- MDN: HTTP Headers — https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers

Your Node.js server just got smarter 🧠⚡️

HTTP is stateless — but your apps don’t have to be.
In this episode, you’ll learn how to manage sessions to persist user data between requests, handle flash messages, and clean up session files automatically — all without a framework.

👉 In this episode, you’ll learn how to:

🔐 Understand the difference between cookies and sessions
🗂️ Build a simple, file-based SessionManager from scratch
💾 Store and retrieve session data safely on the server
⚙️ Add flash messages and automatic session cleanup
🧩 Use JavaScript Proxy objects to auto-save session data

By the end, your Node.js apps will remember — even when HTTP forgets 😉

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Libraries & Docs mentioned:
- Node.js fs: https://nodejs.org/api/fs.html
- Node.js path: https://nodejs.org/api/path.html
- Node.js http: https://nodejs.org/api/http.html
- MDN Proxy: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

Your form validation just got smarter 💪

We’ve built forms, validated input, and handled errors… but what if we could preserve user data, show field-specific messages, and make validation feel seamless? ⚡️

👉 In this episode, you’ll learn how to:

🧠 Use sessions to persist form data across redirects
💬 Display inline validation errors with EJS helpers
⚙️ Implement a back() method for clean redirects
✨ Create a smoother, stateful user experience — no frameworks required

By the end, your Node.js app will remember what users entered, show precise errors, and feel more interactive 🔥

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Libraries mentioned:
- Node.js HTTP: https://nodejs.org/api/http.html
- Node.js Path: https://nodejs.org/api/path.html
- EJS Templates: https://ejs.co/

Your app just got a voice 💬✨

It’s time to give your users clear feedback with flash messages — those friendly pop-ups that say things like “User created” or “Access denied.”

In this episode, we’ll bring interactivity and state together to create a polished, professional experience.

👉 In this episode, you’ll learn how to:

🚀 Implement flash messages using your existing session system
⚙️ Build alert helpers (req.alert.success, req.alert.error, req.alert.warn)
🧩 Pass flash data into your EJS views for dynamic display
💡 Automatically clear messages after they’re shown
🎨 Create a reusable _flash.ejs component for consistent UX

By the end, your Node.js app will communicate like a pro — giving users instant, elegant feedback ⚡️

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Official Docs & Resources:
- Node.js Documentation: https://nodejs.org/en/docs/
- EJS Docs: https://ejs.co/
- MDN Web Docs – JavaScript Guide: https://developer.mozilla.org/en-US/docs/Web/JavaScript

You’ve built forms, handled sessions, and flashed messages — now it’s time to add user authentication like a real web application 💪

👉 In this episode, you’ll learn how to:

🧩 Create a login form and validate user credentials
🔑 Use bcrypt for secure password hashing
🧠 Store authenticated state in your existing session manager
🚪 Implement login, logout, and access control routes
🌐 Update views to reflect authenticated users

By the end, your JavaScript server won’t just remember users — it’ll recognize them 🧠💻

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Current series:
- JavaScript on the Server: https://tekcasts.com/play/javascript-on-the-server

Libraries mentioned:
- bcrypt: https://www.npmjs.com/package/bcrypt
- Node.js http: https://nodejs.org/api/http.html
- Node.js crypto: https://nodejs.org/api/crypto.html

Your Node.js server just got superpowers 💥

We’re taking your app beyond the basics by introducing one of the most powerful architectural patterns in modern web development — middleware ⚙️

👉 In this episode, you’ll learn how to:

🚀 Implement your own middleware system from scratch in Node.js
🔒 Add authentication checks with custom middleware classes
🧠 Use router groups to apply middleware cleanly and efficiently
🪄 Chain multiple middleware functions to handle complex logic
🧩 Understand how frameworks like Express build on this same concept

By the end, your Node.js app will have a clean, modular flow that scales effortlessly 💪

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Previous episodes in this series:
- Sessions: https://tekcasts.com/play/javascript-on-the-server-sessions
- Validation Improvements: https://tekcasts.com/play/javascript-on-the-server-validation-improvements
- Flash Messages: https://tekcasts.com/play/javascript-on-the-server-flash-messages
- Authentication Basics: https://tekcasts.com/play/javascript-on-the-server-authentication-basics

Libraries / Docs mentioned:
- Node.js http: https://nodejs.org/api/http.html
- Node.js URL: https://nodejs.org/api/url.html

Your JavaScript framework is complete 🧠⚙️

In this final refactor, we polish our custom Node.js MVC framework — bringing everything together into a clean, organized, and extensible foundation worthy of real-world projects 💪

👉 In this episode, you’ll learn how to:

🧩 Move core classes like BaseController and BaseModel into the app layer
🧠 Refine the Router to handle static assets and feed request body data to middleware
🔒 Strengthen encapsulation and enforce single responsibility
✍️ Apply DRY principles and consistent coding style across the codebase
🎁 Add a fun “Easter Egg” route using your new framework

By the end, you’ll have built a lightweight but powerful Node.js framework — and gained a deep understanding of how professional frameworks like Express are designed under the hood 🚀

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Libraries mentioned:
- Node.js http: https://nodejs.org/api/http.html
- Node.js fs: https://nodejs.org/api/fs.html
- Node.js path: https://nodejs.org/api/path.html

Your JavaScript framework journey is about to level up 🔍📦

We’ve built our own lightweight Node.js MVC framework — now let’s look outward and explore how it stacks up against several strong contenders in the ecosystem. Why use a framework, when vanilla Node gives you full control? What trade-offs come with more structure? In this episode, we dig deep into those questions.

👉 In this episode, you’ll learn how to:
🚀 Understand the value frameworks bring: structure, built-in features, community, performance
⚙️ Compare what we’ve built against mature solutions
🧭 Decide when it’s worth adopting a full framework and when you might stick with custom
⚖️ Spot the key trade-offs between flexibility and convention

📚 Frameworks we cover:
[03:19] Next.js — https://nextjs.org/
[06:39] NestJS — https://nestjs.com/
[10:38] Express.js — https://expressjs.com/
[13:38] Nuxt.js — https://nuxt.com/
[16:00] Meteor — https://www.meteor.com/
[17:58] Koa.js — https://koajs.com/
[19:20] Fastify — https://fastify.io/
[21:39] Remix — https://remix.run/
[24:04] Sails.js — https://sailsjs.com/
[26:32] AdonisJS — https://adonisjs.com/
[29:06] Hapi.js — https://hapi.dev/


By the end, you’ll not only appreciate how well your custom framework works — you’ll also be ready to evaluate the full-scale options and pick the right tool when it’s time to scale.

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Libraries / Docs mentioned:
- Node.js HTTP: https://nodejs.org/api/http.html
- Node.js URL: https://nodejs.org/api/url.html

Your Node.js journey is about to go live 🌐🚀

You’ve built, refactored, and refined — now it’s time to deploy your application to the real world!
In this episode, we’ll walk through the key steps and best practices for running your Node.js app in production.

👉 In this episode, you’ll learn how to:

⚙️ Configure your app for different environments
📊 Manage logs and monitor performance
🧱 Handle errors gracefully in production
🌱 Use environment variables for configuration
🌀 Keep your app running with process managers like PM2

By the end, you’ll understand what it takes to make your Node.js app not just work — but thrive in production 💪

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Libraries & Tools mentioned:
- PM2 Process Manager: https://pm2.keymetrics.io/
- Node.js Documentation: https://nodejs.org/en/docs/
- dotenv: https://www.npmjs.com/package/dotenv

Your Node.js journey comes full circle 🌎✨

In this final episode of JavaScript on the Server, we recap everything you’ve learned — from your first console.log() to deploying a full-featured web app — and explore what comes next 🚀

👉 In this episode, you’ll:

🧩 Review each module and how it fits into the bigger picture
⚙️ Connect key concepts like routing, MVC, sessions, and middleware
💡 See how frameworks build on the foundation you’ve created
🧭 Discover practical next steps to deepen your skills
🔥 Leave with a clear path forward for your JavaScript and Node.js mastery

By the end, you’ll have a strong grasp of how the server-side ecosystem works — and the confidence to keep building, learning, and exploring 💪

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners → https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser → https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Key Topics from this Series:
- Node.js HTTP → https://nodejs.org/api/http.html
- Node.js fs → https://nodejs.org/api/fs.html
- Node.js path → https://nodejs.org/api/path.html
- EJS Templates → https://ejs.co/
- Express (for further learning) → https://expressjs.com/