New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom your first HTTP request to a secured, deployed API that can handle real traffic.
A 15-step learning path. Follow it in order, or jump to what you need.
For anyone who wants to build the server side of an application, not just consume someone else's API. Plan on about 6 to 10 weeks at a few hours a week, moving from HTTP and Python through a real database, authentication, caching, and queues to an intro to system design. This path stays server-side only (no frontend framework work; that's the Full Stack Developer path) and treats databases and system design as just enough to ship and reason about a real API, not their full depth: SQL & Relational Databases and System Design cover that ground in full. By the end you can build a secured REST API in Python, deploy it without downtime, and reason about how caching, queues, and scaling decisions hold it up under real traffic.
No prior experience needed. Start from zero.
Every status code, header, and method you'll rely on in step 4's REST rules and step 5's FastAPI routes starts here: read this once and you can already explain why a request failed instead of guessing.
Every project from step 3 onward assumes you can commit, branch, and open a pull request, the same history that step 14's deployment pipeline replays on every push.
This is where held-connection async code actually clicks, or doesn't yet: expect to revisit the Async/Await table once step 10's queues force the question. Everything from step 5's FastAPI routes onward is Python you write today.
You can read an HTTP exchange, manage code the way a team does, and write real Python, including the async syntax that trips up most people moving from the frontend. Next up: turning that into an actual API.
Finish this section to unlock.
+100 XP
Turns the raw methods and status codes from step 1 into a real design discipline: resource naming, pagination, and versioning, the rules step 5's FastAPI routes need to follow to make sense to any client.
Gives you a real place to write the REST rules from step 4 in code: routes, validation, and docs generated straight from the Python types you learned in step 3.
Persists what step 5's FastAPI routes create and read: relational storage that survives past one request, the database every step from here forward assumes exists.
Locking down the routes from step 5 is where most learners stall the first time: sessions, API keys, JWTs, and OAuth all solve the same problem differently, and the production deployment in step 14 assumes you've already picked one.
You can design REST endpoints in FastAPI, back them with PostgreSQL, and put real authentication in front of them, the exact point where a demo starts looking like production. Next up: keeping it fast and reliable once real traffic shows up.
Finish this section to unlock.
+100 XP
Grab this if hand-writing every query against step 6's PostgreSQL is starting to feel repetitive: an ORM trades a little control for type-safe models and migrations that hold up as the schema changes.
Cuts the repeat trips to the PostgreSQL from step 6 that slow a request down, though invalidation is the part that bites: get the patterns here before you reach for a cache under real traffic.
Moves the slow work FastAPI shouldn't block a response on into a queue instead, the same held-connection problem step 3's async table warned you about, solved at the architecture level.
Reach for this if your app already leans on the queues from step 10 for real work: worker pools, retries, and scheduling turn a message broker into a system you can trust with production jobs.
You can cache expensive reads and hand slow work off to a queue instead of blocking a request, the patterns that keep a server responsive once real users show up (a few due flashcards from chapter 1 keep Python's async model fresh while you're deep in queues here). Next up: proving it works and putting it in front of people.
Finish this section to unlock.
+100 XP
Proves the endpoints you've built since step 5 actually do what step 4's REST contract promises, catching a broken response shape before a caller does.
Pick this up if you want to know an endpoint is failing before a user emails you: metrics, logs, and traces turn the caching and queue layers from steps 9 and 10 from black boxes into something you can watch.
Ships the tested API from step 12 to production without downtime, the rollout and rollback patterns that turn a working app into one you can trust with real traffic.
Pulls every piece from the HTTP in step 1 to the deployment pipeline in step 14 into one vocabulary: caching, queues, sharding, and trade-offs, the conversation that decides whether you're ready for a senior backend role.
You went from a bare HTTP request to a tested, secured, cached API deployed with zero-downtime releases and the system-design vocabulary to talk about scaling it. That's the Backend Developer badge, earned: you can build, secure, and ship server-side systems on your own.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.