Stop Freezing on Backend Tickets
Become the engineer who owns the whole request, not just the screen.
What You Will Learn
- ✓Design and ship REST APIs in Node, TypeScript, and Express
- ✓Model real data in PostgreSQL with Drizzle and run migrations without panic
- ✓Implement password hashing, JWT auth, and role-based access
- ✓Push slow work into background queues that survive crashes
- ✓Cache the right things and invalidate them at the right time
- ✓Build real-time features over authenticated websockets
- ✓Instrument a backend with structured logs, metrics, and feature flags
- ✓Containerize and ship a production stack you can hand to a teammate
Who Is This For
- Frontend engineers who who freeze the moment a feature needs a real server
- Self-taught developers who who learned to code on YouTube and now want production-grade depth
- CS graduates who with no real exposure to how backends actually run in production
- Career switchers who who want one coherent path instead of a bookmark folder of half-finished tutorials
Curriculum
The absolute basics
5 lessons
Servers from scratch
5 lessons
REST APIs with Express
5 lessons
Data persistence with Postgres
5 lessons
Auth and security
5 lessons
Professional testing workflows
5 lessons
Background jobs with BullMQ
5 lessons
Caching and optimization
5 lessons
DDD and functional architecture
5 lessons
Microservices and events
5 lessons
Ship it: Docker and ci/cd
5 lessons
API hardening
5 lessons
Realtime WebSockets
5 lessons
Observability
5 lessons
Contracts and resilience
5 lessons
Release engineering
5 lessons
Frequently Asked Questions
- Do I need any backend experience?
- No. You need basic JavaScript and a terminal. The first lessons assume nothing about servers, databases, or HTTP. Everything is built up from there.
- Why Node and not Python or Go?
- Because you probably already write JavaScript. Staying in one language lets you focus on the backend ideas, not the syntax. The patterns you learn here transfer directly to any other language.
- Will this prepare me for production?
- Yes. You build the same shape of stack engineers run at real companies: Express, Postgres with Drizzle, Redis, websockets, Docker, structured logging, feature flags, and contract testing. By the end you can defend every layer.
- Is this self-paced?
- Yes. Self-paced with lifetime access. Take it on a weekend or stretch it over a month. You keep everything either way.
Stop Freezing on Backend Tickets
Become the engineer who owns the whole request, not just the screen.
Built for engineers who want depth, not another tutorial playlist
Be honest. Which one sounds like you?
The frontend ceiling
You can ship a UI in your sleep. The moment a feature needs a real server, you freeze and go searching for examples that almost fit.
The tutorial graveyard
Your bookmark folder is full of Node tutorials. None of them taught you what to do when the database goes down.
Cargo-cult Express
You can copy a CRUD route from Stack Overflow but you cannot explain why your middleware ordering breaks auth.
No one to ask
Every blog post assumes you already know what a connection pool, idempotency key, or DLQ is. You do not, and asking feels embarrassing.
The fix is not another framework.
It is owning every layer yourself, once.
Senior engineers aren't better because they know more syntax. They're better because they've:
Each piece earns the next. By the end, the whole backend feels familiar because you built every part of it yourself.
Not another playlist.
A backend you actually built.
You start with a single HTTP request and finish with a containerized Node and Postgres stack with auth, queues, caching, websockets, observability, contracts, and feature flags. No theory dumps. Every concept lands on running code you can clone and break.
The arc of the masterclass
Each phase earns the next. No wasted lessons.
Foundations: CLI, servers, APIs, databases
Build a validating CLI, stand up your first HTTP server, turn it into a layered REST API, and swap the in-memory store for a real Postgres database in Docker.
Real apps: auth, testing, async work, caching
Hash passwords, protect routes with JWT, write professional test suites, push slow work into background queues, and cache the right things the right way.
Architecture and services at scale
Design domain logic with pure functions and the repository pattern, split a monolith into services with events, and ship real-time features over authenticated websockets.
Ship it: Docker, observability, contracts, flags
Containerize the whole stack, add structured logging and metrics, guard your APIs with contracts, and deploy with feature flags and rollbacks.
From first principles to a production stack you can ship.
The absolute basics
Before you serve data, you have to be able to trust it. Build a CLI that reads a messy JSON file and refuses bad records.
What backend even is
The honest mental model of what a backend does and why it exists.
Validating untrusted input with Zod
Schemas, safeParse, and the gatekeeper pattern that protects everything downstream.
Reading and writing files with fs/promises
Async file I/O the modern way, without callback nesting.
Building a tiny CLI with Commander
Named flags, help text, and exit codes the way real backend tools work.
Putting it together: a validating CLI
Compose schemas, file I/O, and Commander into one tool that refuses bad data.
Servers from scratch
Stand up a real HTTP server, expose a health check, and test it without ever binding a real port.
What an HTTP Server actually does
Ports, listening, requests, and responses without the magic.
Your first Express route
app.get, res.json, and the cleanest possible health check.
Server lifecycle: start and stop
Why holding a reference to your running server matters for tests and deploys.
Testing your Server without binding a port
Supertest runs requests through your Express app in memory. No network, no flakes.
Health checks and what happens when nothing matches
Why every real backend has a health endpoint, and how Express handles unknown routes.
REST APIs with Express
Turn one route into a clean, layered CRUD API where every file has one job.
From one route to a real API
REST conventions, resources, and the HTTP verbs that do all the work.
Controller, service, data: one job per file
The simplest architecture rule that pays for itself the first time you have to refactor.
Validation at the boundary
Validate where data enters your system. Trust it everywhere else.
Express router: grouping routes
Pull routes out of index.ts and mount them under a prefix.
Middleware: logging and error handling
Functions that run before your handler. The cleanest way to apply concerns across many routes.
Data persistence with Postgres
Replace the in-memory array with a real database. Same API, durable data.
The restart problem
Why an in-memory array is a demo, not a product.
Postgres in Docker
One command to spin up a real database. No system installs.
Drizzle schemas: tables as TypeScript
Define your database tables in code so the types and the schema can never drift.
Queries: select, insert, delete
The Drizzle query builder, plain English to SQL.
The async shift: services and controllers
Database calls are I/O. Everything that touches them becomes async.
Auth and security
Lock the front door. Hash passwords with bcrypt, issue JWTs, and gate routes by role.
Password hashing with bcrypt
Why passwords are never stored as plain text, and how to hash them without breaking a sweat.
Signup and login flows
Register a new user, verify credentials, and avoid the username enumeration trap.
JWTs and the requireAuth middleware
What a JWT actually is, how to verify it, and how to gate a route.
Roles and requireRole
The smallest possible role check, expressed as a middleware factory.
Wiring auth end to end
Mount the auth router, protect the book routes, and verify the whole flow with curl.
Professional testing workflows
Catch regressions before they ship. Real tests, real databases, real isolation.
Why automated tests
Manual testing does not scale. The testing pyramid, plainly explained.
Unit tests with Jest
Pure functions get pure tests. The simplest tests you will ever write.
Integration tests with Supertest
Hit your real routes against a real database. No browser required.
Disposable databases with Testcontainers
Start a fresh Postgres container per test run so tests never collide with dev data.
What to test, what to skip
Testing everything is a waste. Testing nothing is worse. Pick the right coverage.
Background jobs with BullMQ
Push slow work out of the request path so customers never wait for the things that can happen later.
Why some work does not belong in the request
The Black Friday scenario every backend engineer learns the hard way.
BullMQ and Redis basics
The smallest useful queue, defined once and reused from anywhere.
Workers as separate processes
The API handles requests. The worker handles jobs. Two processes, one queue.
Retries and graceful degradation
The rules that keep the API alive when Redis or the downstream service is having a bad day.
Running it end to end
Two terminals, one queue, one real order flowing through the whole pipeline.
Caching and optimization
Serve hot reads in under a millisecond and invalidate the cache without losing your mind.
Measure before you optimize
Find the hot path before you touch a single line of cache code.
Cache-aside pattern with Redis
Check the cache, fall through to the database, store the result. The simplest pattern that works.
TTLs and key design
Name your keys so invalidation is easy, and pick a TTL you can defend.
Cache invalidation that actually works
The half of the famous joke that actually bites.
When not to cache
The strongest caching skill is knowing when to leave things alone.
DDD and functional architecture
Keep business rules pure, I/O at the edges, and the codebase survivable for the next six months of feature churn.
Why architecture matters when the codebase grows
Fat services, tangled dependencies, and the cost of having no layers.
Pure domain functions
Business rules as functions you can test without a database.
Value objects with Zod
Encode business rules as schemas so invalid data cannot sneak into the domain.
Repositories and use cases
One place for database queries. One place for the workflow. Everything else stays pure.
A clean slice end to end
Refactor the order endpoint from the inside out and feel the difference.
Microservices and events
Split a service without creating a distributed monolith. Events over HTTP, eventual consistency, and data ownership.
When a monolith starts hurting
The real reasons to split. And the real reasons not to.
Sync calls vs events
Why service-to-service HTTP is a trap, and events are the escape.
Publishing and subscribing with Redis
The smallest possible event bus. Publisher and subscriber in ten lines each.
Eventual consistency, plainly
The tradeoff you accept in exchange for loose coupling.
Running two services end to end
Three terminals, two services, one event flowing through the whole system.
Ship it: Docker and ci/cd
Package the whole stack so any machine can run it with one command, and block bad code at the door.
What "Production" Actually Means
The gap between it works on my machine and it runs anywhere, reliably.
Multi-stage dockerfiles for Node
A small, safe production image without shipping dev dependencies.
Docker compose for the Whole Stack
Every service, every port, every env var in one file.
CI with GitHub Actions
Block broken code from merging with a tiny workflow file.
The hardening checklist
The final checklist before you hit deploy.
API hardening
Make your API survive the hostile internet. Pagination, rate limiting, uploads, versioning.
Cursor vs offset pagination
Why OFFSET gets slow and cursors stay fast.
Rate limiting
Stop one client from monopolizing your API.
Safe file uploads with multer
Accept files without accepting ../../../etc/passwd.
API versioning
Ship breaking changes without breaking existing clients.
Input validation as defense
Validate query params, not just bodies, and feel the last layer of the hardening story fall into place.
Realtime WebSockets
Ship live updates without polling. Authenticated rooms, typed messages, and dead connection cleanup.
HTTP is email. WebSocket is a phone call.
The mental model that makes the rest of the module obvious.
The upgrade handshake and JWT on upgrade
How a websocket starts life as an HTTP request, and how to gate it with your existing auth.
Rooms and broadcasting
Target messages to the clients that care, not to all ten thousand.
Typed messages and routing
Give the socket a tiny protocol so clients and servers speak the same language.
Heartbeat and reconnection
Detect dead connections and clean them up before they rot.
Observability
See what your backend is doing at 2 AM. Structured logs, health checks, correlation IDs, and graceful shutdown.
Structured logging with pino
Replace console.log with JSON logs your tools can actually search.
Request IDs and correlation
Follow one user across every log line, every service, every downstream call.
Liveness vs readiness
The two different health questions orchestrators ask, and why the wrong answer breaks deploys.
Metrics: counts, latency, errors
The three numbers every backend has to expose, and the one dashboard that covers most outages.
Graceful shutdown
Finish what you started before the process dies.
Contracts and resilience
Publish what your API promises and prove it survives the failure modes you planned for.
What an API contract actually is
A promise your service keeps, and the shape that everyone downstream depends on.
Publishing an OpenAPI spec
Make the contract a machine-readable document your CI can check.
Contract testing
Prove that the spec and the code still agree, automatically.
Resilience drills
Rehearse the bad day before the bad day happens.
Timeouts, retries, and circuit breakers
Patterns that stop one slow dependency from taking the whole service down.
Release engineering
Deploys should be boring. Feature flags, canaries, rollbacks, and load drills make them that way.
Feature flags as a deploy strategy
Decouple code deploy from feature release.
Canary releases and rollback
Ship to 1 percent, watch the dashboards, then ship to everyone. Or roll back in one command.
Load tests before deploy
Catch regressions in speed before your users do.
Capstone reflection
Zoom out and see the shape of what you just built.
Where to go next
The map of the rest of the journey, and how to keep the skill.
Workshop Curriculum
What you'll build in this hands-on workshop.
Anyone can hit /api/users. Engineers understand what happens after.
AI can scaffold an Express route.
Boilerplate, controllers, basic CRUD.
AI cannot give you:
- A working mental model of the request lifecycle
- The instinct to spot a missing index or a leaky cache
- Confidence to design the data model before writing code
- The judgement to know when to add a queue, a flag, or a contract test
That comes from building it yourself. That is what this masterclass is.
Learn From Someone Who Actually Does This
I am the Head of Engineering at Jobbatical (EU Tech), with 8+ years of leadership and 15+ years of total experience in the software industry.
"Most engineers are not blocked by ability, but by lack of real system ownership."
Guest Sessions From Engineers at
Live sessions on System Design, Career Growth, and Interview Preparation.
Get Full Access
Invest in your career. It pays back 100x.
Frequently Asked Questions
Do I need any backend experience?
Why Node and not Python or Go?
Will this prepare me for production?
Is this self-paced?
When you finish:
Stop bouncing between tutorials. Build the backend brain.
Enroll in this Course
Enter your email to proceed to checkout.
Includes lifetime access to the interactive course.