18 stations on 3 ladders, in order — each rung is written assuming the one above it. Mark them off as you go; your progress is saved in this browser.
0 / 18
Pick up at
Track 1 of 3
FoundationsStart here
6 rungs · ~5h · ends at Auth & Security.
0/6 done
1
Language & Runtime
Start here
F1 · Beginner · 45 min
Backend work starts with a language and the runtime under it. Pick one (Go, Java, Python, Node, Rust), and understand how it handles concurrency, memory, and packages — because the runtime shapes every performance and scaling decision you make later.
Choosing a language
Concurrency model
Memory & GC basics
Package management
Build itWrite a tiny HTTP server in your language that returns JSON. Note how it handles concurrent requests — threads, an event loop, or goroutines?
✓ CheckpointExplain what your language's concurrency model actually gives you — threads, an event loop, or something else — and which workloads it is wrong for.
The web speaks HTTP, and most backends expose REST APIs. Master the request/response cycle, methods and status codes, statelessness, idempotency, and clean resource design — the vocabulary every service and every interview is built on.
Build itDesign the REST API for a pastebin: list the endpoints, methods, status codes, and request/response shapes. Which calls are idempotent?
✓ CheckpointJustify the status code you return when a request is well-formed but the action is not allowed, and say why 200-with-an-error-body is a lie.
The relational database is the heart of most backends. Learn the relational model, joins, indexes and B-trees, transactions and ACID, and how the query planner turns your SQL into a fast (or slow) plan. This is where correctness and performance meet.
Relational model & joins
Indexes & B-trees
Transactions & ACID
EXPLAIN & query plans
Build itModel a simple e-commerce schema (users, orders, products). Add the indexes a checkout query needs, and check the plan with EXPLAIN.
✓ CheckpointRead an EXPLAIN plan and say which index the planner used and why. If you cannot, you are tuning by guesswork.
A cache is the highest-leverage tool for read-heavy backends: keep hot data in memory and spare the database. But caches bring their own problems — TTLs, eviction, invalidation, and the thundering herd when they go cold. Redis is the workhorse.
Not everything fits a relational schema. Key-value, document, and wide-column stores trade joins and strict schemas for scale and flexible access patterns. The skill is modeling your data for how it will be read, and knowing when NoSQL beats SQL.
Key-value / document / wide-column
Access-pattern modeling
Denormalization
When NoSQL fits
Build itFor a chat app, decide where messages, user profiles, and presence each live — and justify SQL vs NoSQL for each by its access pattern.
✓ CheckpointTake an access pattern and design the key for it — then say what query becomes impossible as a result.
Every backend must answer "who are you, and what may you do?" Learn authentication vs authorization, sessions vs JWTs, OAuth, password hashing, and the OWASP risks (injection, XSS, CSRF) — plus TLS. Security is not a feature you bolt on later.
Authn vs authz
Sessions & JWT
OAuth basics
Password hashing & OWASP
Build itDesign auth for an API: how do you issue and verify tokens, store passwords, and stop a stolen token being replayed forever?
✓ CheckpointState the difference between authentication and authorisation in one sentence, and name where your system checks each.
Good APIs outlive their implementations. Beyond basic REST: pagination, consistent error handling, versioning without breaking clients, rate limiting, and when GraphQL or an API gateway earns its place. Design the contract as carefully as the code.
Pagination & filtering
Error handling & idempotency keys
Versioning
REST vs GraphQL / gateway
Build itEvolve a v1 API to v2 without breaking existing clients. Where do you version, and how do you deprecate gracefully?
✓ CheckpointExplain why an idempotency key is a correctness feature and not a convenience, using a retried payment as the example.
One server has a ceiling. Scale out with stateless services behind a load balancer, and understand connection pooling, horizontal vs vertical scaling, and where shared state must live. Statelessness is the enabler for everything horizontal.
Horizontal vs vertical
Stateless services
Load balancing (L4/L7)
Connection pooling
Build itTake a single-server app to five servers. What must become stateless, where does session/state move, and how does traffic get distributed?
✓ CheckpointExplain what makes a service stateless, and where the state you removed actually went.
Untested backends rot. Learn the test pyramid — many fast unit tests, fewer integration tests, a handful of end-to-end — plus mocking, test data, and contract tests between services. Tests are what let you change code without fear.
Test pyramid
Unit / integration / e2e
Mocking & fixtures
Contract testing
Build itFor a payment endpoint, decide what to unit-test, what needs an integration test with a real database, and what an e2e test should cover.
✓ CheckpointExplain what a contract test catches that unit tests on both sides structurally cannot.
Not everything should happen in the request. Queues and logs decouple producers from consumers, absorb bursts, and enable async work and event-driven architecture. Learn at-least-once delivery, idempotent consumers, and queues vs a Kafka-style log.
Async decoupling
Queue vs log (Kafka)
At-least-once + idempotency
Event-driven design
Build itMove email-sending out of the checkout request. Which queue guarantees do you need, and how do consumers avoid sending duplicates?
✓ CheckpointExplain why at-least-once delivery forces idempotent consumers, and what breaks the day you assume exactly-once.
You cannot fix what you cannot see. Instrument the three pillars — metrics (is something wrong?), logs (what happened?), traces (where?) — with structured logs and the golden signals, so 3am debugging is a guided walk, not a guessing game.
Metrics / logs / traces
Structured logging + trace ids
Golden signals
SLIs / SLOs
Build itAdd observability to a slow endpoint: which metric alerts you, which trace localizes it, and which log lines explain it?
✓ CheckpointExplain what you would look at first when latency rises but error rate does not, and which of the golden signals that is.
Now assemble the pieces. Back-of-the-envelope estimation, the CAP tradeoff, consistency models, and combining APIs, databases, caches, queues, and load balancers into a coherent system that scales — the skill senior interviews probe hardest.
Capacity estimation
CAP & consistency
Component composition
Tradeoff reasoning
Build itDesign a URL shortener end to end: estimate the numbers, pick the datastore, add the cache, and justify every component.
✓ CheckpointDo a capacity estimate out loud — requests, storage, bandwidth — and say which number you are least confident about.
Modern backends ship as containers. Learn Docker images, then orchestration: how Kubernetes runs hundreds of containers across machines by chasing a declared desired state, self-healing, load-balancing, and rolling out new versions.
Docker images
Pods & deployments
Desired-state control loop
Services & self-healing
Build itContainerize a service and declare 3 replicas. What happens when one pod crashes, and how does a rolling update stay available?
✓ CheckpointExplain what the desired-state control loop does when you delete a pod by hand, and why that is the whole idea.
Shipping should be boring. Automate build, test, and deploy in a pipeline, and release safely with blue-green or canary deploys, quick rollbacks, and feature flags that decouple deploy from release. Deploy small, deploy often, deploy reversibly.
CI/CD pipelines
Blue-green & canary
Rollbacks
Feature flags
Build itDesign a safe rollout for a risky change: how do you release to 1% first, watch metrics, and roll back in seconds if it breaks?
✓ CheckpointExplain what a canary tells you that a staging environment cannot.
Everything fails eventually. Build services that degrade gracefully: timeouts so a slow dependency cannot hang you, retries with backoff, circuit breakers that stop cascading failure, and bulkheads that isolate blast radius. Assume dependencies will break.
Timeouts
Retries & backoff
Circuit breakers
Graceful degradation
Build itA downstream service gets slow. Show how timeouts, a circuit breaker, and a fallback keep your API responsive instead of hung.
✓ CheckpointExplain why a retry without backoff and jitter makes an overloaded service worse, not better.
When one database is not enough: replicate for read scale and availability, and shard (partition) to spread writes and storage across machines. Learn read replicas, partitioning strategies, and the consistency tradeoffs each choice forces.
Read replicas
Sharding / partitioning
Partition keys & hotspots
Replication consistency
Build itYour users table is too big for one node. Choose a shard key, avoid hotspots, and explain what a cross-shard query costs.
✓ CheckpointPick a partition key for a real table and name the hotspot it creates. Every choice creates one somewhere.
Distributed backends bite in subtle ways: coordinating with distributed locks (and why they are hard), making operations idempotent so retries are safe, exactly-once myths, and clock/ordering issues. These are the traps senior engineers must see coming.
Distributed locks & fencing
Idempotency
Exactly-once vs at-least-once
Ordering & clocks
Build itTwo workers might process the same job. Make the handler idempotent so a duplicate is harmless — without a fragile lock.
✓ CheckpointExplain why a distributed lock without fencing is unsafe even when the lock service is working correctly.
Operating a backend is a discipline. Define SLIs/SLOs and an error budget to balance features against reliability, plan capacity and control cost, and run humane on-call with good alerts (symptoms, not noise) and blameless incident response.
SLIs / SLOs / error budgets
Capacity & cost planning
Alerting on symptoms
Incident response
Build itSet an SLO for a checkout API and derive its error budget. When the budget is spent, what should the team stop doing?
✓ CheckpointExplain what an error budget lets you do that an uptime target alone does not.
All 18 rungs on one screen. Each track assumes the one before it; the highlighted rung is where a track ends and the next one picks up.
Track order matters more than rung order inside a track: finish a track's last rung before starting the next track.
Worked example: a three-hours-a-week plan
Say you have three focused hours a week — an evening or two. Take the rungs in order and never split one across two weeks; a rung that would push the week past three hours starts the next week. The rung times add up to 18h 5m.
Week
Rungs
Time
Week 1
F1 Language & Runtime, F2 HTTP & REST APIs, F3 SQL Databases
That is 7 weeks of reading. The Build-it exercise on each rung is extra and is where most of the learning happens, so plan to spend at least as long building as reading — or halve the pace and do both in the same week.
What each track costs in time
The rung times above, added up per track. Use it to plan the slow stretch: a track that takes a larger share of the total is where the plan above spends more weeks.
Track
Rungs
Time
Share
Longest rung
1. Foundations
6
6h
33%
F3 SQL Databases (1h 15m)
2. Core Backend
6
6h
33%
T6 System Design (1h 15m)
3. Production
6
6h 5m
34%
P1 Containers & Kubernetes (1h 10m)
Common mistakes on the Backend Engineer path
Treating SQL as syntax, not as a planner
People learn SELECT and joins in F3, then skip indexes and EXPLAIN. Months later they reach for sharding (P4) to fix a query that only needed the right index.
Caching to hide a slow query
A cache (F4) in front of an unindexed query buys speed and a new bug class: stale reads and invalidation. Fix the query first, then cache what is still hot.
Assuming a message arrives once
Queues deliver at least once (T4). A consumer that is not idempotent sends the email twice or charges the card twice the first time a worker crashes before it acks.
Retrying without timeouts or backoff
A call with no timeout hangs your threads when a dependency slows down. Instant retries then multiply the load on the service that is already struggling (P3).
A portfolio of CRUD apps
Five to-do APIs show the same skill five times. One service carried through tests (T3), metrics and traces (T5) and a canary deploy (P2) shows the job.
Where this shows up: jobs and interviews
The day-to-day work
Designing endpoints and schemas, writing migrations, reviewing queries, and reading dashboards and traces when something is slow. On-call means turning an alert into a cause, which is T5 and P3 in practice.
What interviews probe
Most loops have a coding round and questions on HTTP, databases and caching (F2–F5). Mid and senior loops add a system design round, built from T6, P4 and P5.
Debugging and take-homes
Expect “latency went up, what do you check?” style questions (T5, P3). A take-home is usually a small API, where clean status codes (F2), pagination and errors (T1) and tests (T3) are what reviewers read.
Showing it in a portfolio
Deploy one service and write a README that explains the schema, an EXPLAIN plan for the main query, where the idempotency key lives, and what you would alert on. Reasoning beats repo count.
Check yourself
Open a question only after you have answered it out loud. If one stumps you, the rung in brackets is where to go back to.
A client times out on POST /payments, retries, and the customer is charged twice. What fixes it?
An idempotency key. The client sends one key per logical payment; the server stores the key with the result under a unique constraint and returns the stored result on a retry instead of charging again. (T1)
p99 latency doubles but the error rate is flat. Where do you look first?
Latency is one of the golden signals, so start with the latency graph by percentile. Then open a slow trace to find which span grew, and read the logs for that trace id. Saturation, such as an exhausted connection pool, is a common cause. (T5)
After a worker crash, some users get the welcome email twice. Why, and what is the fix?
The worker sent the email but crashed before acknowledging, so the queue redelivered it. Record a dedupe key (the message or user id) and skip work already done. Do not try to make the queue exactly-once. (T4)
A downstream service gets slow and your API starts hanging. Which three tools keep it responsive?
A timeout on every call, a circuit breaker that stops calling after repeated failures, and a fallback such as cached or partial data. Any retries need backoff and jitter. (P3)
The common questions before you start — how long it takes, whether to follow it in order, and how it stays current.
How long does this roadmap take?
It runs 18 stations across 3 tracks — roughly ~16h of focused learning, plus the time you spend actually building. It is self-paced, so most people work through it over a few weeks, an evening or a single station at a time.
Do I have to follow the stations in order?
The tracks are ordered so each station builds on the one before, and following them start to finish is the intended path. But every station also stands alone — if you already have the foundations, jump straight to the part you need.
Is it free?
Yes. The whole roadmap, and every handbook, lab, and challenge it links to, is free and open — no sign-up and no paywall.
How is the roadmap kept current?
It teaches the durable fundamentals of the role first, then the tooling and the AI-era shifts on top — so most of it stays relevant as individual tools churn, and it is revised as the role itself changes.
Who is this roadmap for?
Anyone stepping into or leveling up in the Backend Engineer role — whether you are switching in, early-career, or a senior filling gaps. Start where you are; the ladder shows what is left.