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 spotting a SOLID violation in code review to defending a monolith-to-microservices migration plan.
A 15-step learning path. Follow it in order, or jump to what you need.
For senior developers and tech leads ready to own a system's shape, not just the code inside it, and the trade-offs that come with that responsibility. Plan on about 7 to 12 weeks at a few hours a week, moving from spotting a SOLID violation through domain modeling and architecture styles to the documentation, governance, and migration skills a senior architecture role actually runs on. This path assumes you can already design and ship a service on your own (Backend Developer and System Design cover that ground) and stays off the caching, database, and interview-format material System Design already owns; here the focus is organizational judgment: modeling a domain, choosing and documenting a shape, and defending it to the people who'll live with it. By the end you can write an ADR someone can actually audit, wire a fitness function that fails a build on an architecture violation, and plan a monolith-to-microservices migration without a rewrite.
Expected: several years building and shipping real systems, comfortable working inside at least one architecture style already (see Backend Developer or Full Stack Developer). Helpful but not required: System Design's caching and database trade-offs, and having led a technical decision that other people had to live with.
Every architecture decision from here starts as a smaller decision about coupling and responsibility, and SOLID gives you the words to spot a bad one in a single pull request, before it becomes tomorrow's migration.
Turns the coupling and responsibility rules from step 1 into named, reusable solutions: once you can say this is Strategy, not a switch statement, a whole team can talk about a design without drawing a diagram.
Zooms out from the object-level patterns in step 2 to the shape of the whole system: layered, event-driven, distributed, so you can name the architecture you're already living in before you try to change it.
This is where the system shapes from step 3 stop being enough: expect bounded contexts and ubiquitous language to feel abstract at first, because they reorganize how you read every requirement instead of just where code lives.
You can spot a SOLID violation, name the design pattern behind a messy switch statement, and describe your system's architecture style out loud, crossing into the bounded contexts that Domain-Driven Design reframes everything around. Next up: modeling the domain that shape is supposed to serve.
Finish this section to unlock.
+100 XP
Gives you the room-sized exercise that actually finds the bounded contexts step 4 asked for: sticky notes and domain experts in one session surface boundaries that a diagram alone never would.
Builds the domain layer step 4 described into something concrete: ports and adapters keep the business rules you just modeled from ever depending on a database driver or a framework version.
Takes the boundaries from step 5's workshop and step 6's ports and enforces them inside one deployable app, the pragmatic default most teams should reach for before step 8's full distribution.
Take this if your organization is already outgrowing step 7's modular monolith: full service independence solves real scaling and team-autonomy problems, at the cost of every distributed-systems trade-off System Design covers in depth.
You can run an Event Storming session to find real bounded contexts, wire a hexagonal domain that doesn't know its database exists, and explain why a modular monolith beats microservices for most teams (a few due flashcards from chapter 1 keep SOLID and the pattern vocabulary fresh while you're deep in domain modeling here). Next up: splitting how your system reads from how it writes.
Finish this section to unlock.
+100 XP
Separates the read and write sides of whichever shape you picked in step 7 or step 8, so a reporting query stops competing with a checkout write for the same schema.
Pushes step 9's separation further: instead of overwriting state, you keep every change as a fact, the pattern behind the audit trail and time-travel debugging your DDD aggregates from step 4 now support.
Reach for this once step 7 or step 8 already has modules or services talking across a boundary you don't fully control: contract tests catch a broken interface before a deploy does, without standing up a full integration environment.
Writes down every choice from steps 4 through 10 in a form someone can actually review: ADRs and C4 diagrams turn we decided in a meeting into a record the next architect can audit.
You can split a system's reads from its writes with CQRS, explain why an event log outlives any single database table, and turn a decision made in a meeting into an ADR someone can actually audit months later. Next up: making the rules you just wrote down impossible to ignore.
Finish this section to unlock.
+100 XP
Automates the review step 12 wrote down: expect your first fitness function to fail against code that has been fine for years, the moment architecture stops being a document and starts being a test that runs on every commit.
Gives the violations step 13's fitness functions catch a name and a priority: not every broken rule needs fixing today, and this is how you decide which one actually does, in terms a non-technical stakeholder will accept.
Pulls every step before this into one real decision: the strangler fig pattern uses the boundaries from step 5's workshop, the module discipline from step 7, and the debt priorities from step 14 to move a live system without a rewrite.
You went from spotting a SOLID violation to writing fitness functions that fail a build automatically, pricing technical debt in terms a stakeholder will act on, and planning a live monolith-to-microservices migration without a rewrite. That's the Software Architect badge, earned: you can design, document, and defend a system's shape to the people who have to live with it.
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.