Build-in-public. 134 steps. One real system.

You have finished the tutorials and you ship features. Then someone asks you to design the system and defend the trade-offs, and you freeze.

Go from an empty machine to a system you can defend in a design review.

ArchitectPath is a 134-step path where you build one real app with an AI coding agent. Each step adds about one new thing and explains the decision behind it, so you learn to reason like a Solution Architect.

Not live yet. Join the waitlist and be first in when it launches. Read the syllabus

// what it is

One app. 134 steps. The full stack, in order.

You build FlowMart, one real application, from an empty machine to a multi-cloud, Zero-Trust platform. The ramp is gentle: Static HTML, then JS, Next.js, Docker, Kubernetes, app features, data, observability, messaging, then cloud. Each step reads as the next chapter of one long build, and an AI agent does the typing while you own the structure and the decisions.

  • 134 steps, 00 to 133
  • Plain English, every term explained
  • Tests every code step
  • Real SLOs you measure against

// who it's for

For the developer stuck between "can code" and "can architect".

You already have

  • Some React and a backend language
  • Comfort with Git and the command line
  • Features shipped, tutorials finished

You want to grow into

  • Full-stack plus DevOps plus architecture
  • Tech-lead and Solution-Architect work
  • Owning the decisions behind the code

// how it works

Start from an empty folder. Add one thing at a time.

Step 00 sets up an empty machine, and step 01 is a single static HTML page. Nothing is set up for you in advance. From there each step adds about one new piece and fits in a single AI-agent chat, so the ramp is gentle and there are no big jumps. By the end you have taken one app from a single HTML file to a distributed, multi-cloud, Zero-Trust system, and you can explain every decision that got it there.

You read the goal for a step, make the architecture call yourself, and the AI agent does the typing. Every step also has a short trade-offs note and a build-by-hand task, so you practise the reasoning yourself. You own the structure and the decisions; the agent writes the code.

The ramp, stage by stage:

  1. 00FoundationsStatic HTML, JavaScript, Next.js, then Docker, Kubernetes and Helm.
  2. 08The productCatalog, auth, cart, admin, and the databases behind them.
  3. 21Running itA hardened VPS, metrics, logs, traces, alerts, and the SLOs you measure against.
  4. 27DistributedA second service, load balancers and an API gateway, RabbitMQ, Kafka, sagas, autoscaling, load tests, then features in depth.
  5. 59PlatformsAI and MCP, Spark and Cassandra and ClickHouse, failover you measure, CI/CD, Terraform, multi-cloud and regions, Zero Trust.
  6. 108War RoomTwenty-six steps built on real big-company outages, reproduced in miniature and worked like an on-call shift.

Capacity-aware by design: from step 22 the heavy services run on a cheap rented VPS while the app stays on your laptop, because a 16 GB machine cannot hold the whole stack. Later it moves to IaC, then the cloud.

See all 134 steps

// syllabus

Every step, in order.

Thirteen blocks, 134 steps, one app. Open a block to see the exact steps it contains. Each step is a build with a definition of done, tests, and a trade-off note that compares the tool with its alternatives.

Core track 00–107War Room 108–133

00–07 Foundations An empty laptop to a working app inside Kubernetes. 8 steps
  1. 00Environment bootstrap + Linux/vim basics
  2. 01Static storefront page
  3. 02Interactivity + first API call (JS → FastAPI)
  4. 03Next.js rebuild
  5. 04Dockerize
  6. 05Kubernetes basics
  7. 06Helm packaging
  8. 07Repo automation (Makefile task runner + robust bash scripting)
08–17 The shop Catalog, login, cart, admin, and the databases under them. 10 steps
  1. 08Catalog browse (read-only)
  2. 09Auth: JWT
  3. 10Cart & orders
  4. 11Admin: products
  5. 12Postgres
  6. 13MySQL schema design + normalization (1NF/2NF/3NF, then deliberate denormalization)
  7. 14MongoDB
  8. 15Redis cache
  9. 16Memcached vs Redis (when to pick which cache)
  10. 17Best-sellers leaderboard (Redis sorted sets)
18–20 Plan and numbers Write the spec, count the load, catch your first race condition. 3 steps
  1. 18Product spec (NFR + SLI/SLO/SLA)
  2. 19Capacity planning & system design
  3. 20Reservations & concurrency/race lab
21–26 Watch it run Rent a server. Add metrics, logs, traces and alerts. 6 steps
  1. 21Observability: Prometheus + Grafana
  2. 22VPS provisioning & hardening
  3. 23Logging: ELK pipeline (Filebeat/Logstash) + Loki bake-off
  4. 24Product search + typeahead (inverted index, trie)
  5. 25Distributed tracing
  6. 26Alerting: email + Telegram
27–42 Many services Split it up. Load balancers, an API gateway, queues, sagas, autoscaling, then break it on purpose. 16 steps
  1. 27Security hardening
  2. 28Data governance & PII
  3. 29Second service: Node/Express catalog
  4. 30Load balancing: L4 and L7
  5. 31API gateway (HelloFresh)
  6. 32Geospatial locator (geohash, "near me")
  7. 33RabbitMQ basics
  8. 34Saga + compensation
  9. 35Kafka event streaming
  10. 36Transactional outbox (reliable publish, no lost events)
  11. 37Resilience patterns
  12. 38Workflow orchestration engine (Temporal durable execution vs the hand-coded saga)
  13. 39Load testing: k6 + JMeter
  14. 40Autoscaling: HPA, KEDA and node capacity (Delivery Hero)
  15. 41eBPF profiling & flamegraphs (find the real bottleneck)
  16. 42Incident response: game day
43–58 Real features Payments, realtime, wallet, media and big uploads, gRPC, GraphQL, mobile and offline. 16 steps
  1. 43E2E testing
  2. 44A/B testing
  3. 45Realtime: WebSockets
  4. 46Chat data model + capacity (messages, fan-out write vs read, timelines)
  5. 47Collaborative cart (CRDT merge)
  6. 48Payments: provider integration (Stripe)
  7. 49Payments: edge cases
  8. 50Store-credit wallet (event sourcing)
  9. 51Media + background jobs (image thumbnails + video transcoding)
  10. 52Large file upload: multipart and resumable
  11. 53gRPC internal
  12. 54GraphQL API
  13. 55Frontend performance (Core Web Vitals, code splitting, images, budgets)
  14. 56Mobile API optimization + BFF (thin payloads, one call per screen, offline sync)
  15. 57PWA (service worker, offline shell, install, background sync, push)
  16. 58Brownfield migration & deprecation
59–64 AI inside the app An LLM layer, an agent, MCP on both sides, an agent that is safe in production, automation. 6 steps
  1. 59LLM provider abstraction
  2. 60AI agent + MCP
  3. 61MCP server (stdio JSON-RPC)
  4. 62MCP client (Streamable HTTP)
  5. 63Production agent (human approval, durable runs, budgets)
  6. 64n8n automation
65–81 Big data and stores Six more databases, a matching engine, one you write yourself, and failover that you measure. 17 steps
  1. 65Spark batch analytics
  2. 66Hadoop: HDFS
  3. 67Databricks
  4. 68Catalog ingestion crawler (price & supplier data)
  5. 69Go inventory service
  6. 70Marketplace matching engine (order book)
  7. 71Cassandra + consistent hashing
  8. 72Database sharding (shard key, routing, cross-shard reads, resharding)
  9. 73NoSQL single-table design (access-pattern-first, one table, no joins)
  10. 74LSM storage engine from scratch (memtable, WAL, SSTable, compaction)
  11. 75Consensus & coordination (leader election, split-brain, fencing)
  12. 76High availability per component: Postgres, Redis, the front door
  13. 77Deterministic simulation testing (seeded scheduler, replay a bug)
  14. 78neo4j: recommendations
  15. 79ClickHouse OLAP + probabilistic counting (HyperLogLog)
  16. 80InfluxDB: time-series
  17. 81Cross-engine migration (Mongo → Postgres, translate shape + reconcile)
82–90 Ship it Pipelines, Terraform, Ansible, single sign-on, two more languages. 9 steps
  1. 82CI/CD: GitHub Actions / GitLab
  2. 83Jenkins pipeline
  3. 84Progressive delivery & paved road
  4. 85Terraform IaC
  5. 86Ansible provisioning
  6. 87Ecosystem SSO: Google + SAML
  7. 88Polyglot frontends
  8. 89Nest.js service
  9. 90Migrate to cloud
91–95 Cloud and regions The same stack on AWS, Azure and GCP, then two live regions and global traffic steering. 5 steps
  1. 91Cloud AWS: EKS
  2. 92Cloud AWS native: Bedrock + Lambda
  3. 93Cloud Azure: AKS
  4. 94Cloud GCP: GKE
  5. 95Regional clusters and global traffic steering
96–105 AI in production RAG that works, evals, cost control, guardrails, fine-tuning. 10 steps
  1. 96Prompt engineering (versioned + regression-tested)
  2. 97RAG production
  3. 98Vector DB tuning (ANN index + recall)
  4. 99RAG evals + observability
  5. 100Agent eval harness (trajectory + tool-call accuracy, not just the answer)
  6. 101LLM output validation (schema + repair)
  7. 102AI observability (errors, latency, cost)
  8. 103Efficient inference: vLLM
  9. 104AI security & guardrails
  10. 105Fine-tuning: LoRA/QLoRA (optional)
106–107 Lock it down Zero Trust, then you attack your own app on purpose. 2 steps
  1. 106Zero Trust: mTLS/mesh
  2. 107Offensive security lab (attack your own app)
108–133 War Room 26 steps built on real outages, rebuilt on a laptop and one server. 26 steps
  1. 108Retry storm / metastable failureMeta / Rockset
  2. 109A regex that pegged every CPU (Cloudflare 2019)Cloudflare 2019
  3. 110Gray failure (differential observability)Microsoft Azure
  4. 111Shuffle sharding (blast-radius isolation)AWS
  5. 112Cache stampede / hot keycache stampede
  6. 113Flash sale: virtual queue (Shopify)Shopify
  7. 114A region dies, move everyone (Netflix)Netflix 2012
  8. 115Online schema migration under load (GitHub/Uber)GitHub / Uber
  9. 116Zero-downtime data movement (Stripe)Stripe
  10. 117Multi-region & split-brain (Figma)Figma
  11. 118Split-brain from cross-region failover (GitHub 2018)GitHub 2018
  12. 119Idempotency key: double charge (Stripe)Stripe
  13. 120Trillion-event delivery pipeline (Spotify)Spotify
  14. 121LLM router misroutes servers (Anthropic)Anthropic
  15. 122Silent inference-quality corruption (Anthropic)Anthropic
  16. 123KV-cache economics (Character.AI)Character.AI
  17. 124One control plane over 7500 nodes (OpenAI)OpenAI
  18. 125Training fault tolerance + SDC (Meta/ByteDance)Meta / ByteDance
  19. 126Config-change blast radius (Cloudflare/Spotify)Cloudflare / Spotify
  20. 127One letter in a YAML file deletes your DNS (Zalando)Zalando 2022
  21. 128The 45-minute deploy disaster (Knight Capital)Knight Capital
  22. 129Cascading dependency failure (AWS)AWS
  23. 130One mistyped command takes down S3 (AWS 2017)AWS S3 2017
  24. 131Locked out of your own network (Facebook BGP 2021)Facebook BGP 2021
  25. 132Automated quota takes down login for everything (Google)Google 2020
  26. 133Diagnosing a bug nobody could explain for over 2 years (Facebook)Facebook

On pinned steps you write the decision record yourself: you make the call, the agent writes it up. The whole roadmap exists in English and Russian, with every technical term explained the first time it appears.

WAR ROOM steps 108–133

Reproduce real big-company outages, in miniature.

The last track has 26 steps built on documented outages and failure patterns from Cloudflare, GitHub, Stripe, AWS, Meta, Google and others, run on your laptop and one server. You reproduce each failure on purpose, work it like an on-call engineer, then build the safeguard that stops it and prove it with a test.

// what makes it different

Built to teach the decisions behind the code.

Architect skill, from step one

Most steps carry a short trade-off note: the real alternatives, and when this tool is the wrong choice. You make the call, the agent writes it up.

Real docs on real steps

You write ADRs, C4 diagrams and design docs on the steps that deserve them, using filled-in examples modelled on Big-Tech docs.

Build it by hand

On most steps you write the core mechanism yourself or fix a bug planted on purpose. On the rest the agent works alone and you check its summary. How you work a step matters more than the topic.

Tests on every step

Unit and integration tests, including a failing case, are part of what "done" means on every code step. Early on you write them yourself.

Choose tools by measuring

You pick a database or a vendor with a small bake-off and a weighted matrix, then defend the choice out loud with your own numbers.

Runs on the laptop you already have

Heavy services move to a cheap rented server, so a 16 GB laptop is enough for the whole course and the server bill stays small.

// faq

Questions worth answering.

Do I need an AI coding agent?

Yes, the path is built around one. Cursor, Claude Code, or a similar agent does the typing while you own the structure and the decisions. Each step is written to fit in a single agent chat.

What do I actually build?

FlowMart, one real application, from an empty machine to a multi-cloud, Zero-Trust platform. The roadmap tells you the what and the order. You build the app in a separate repo.

What will I walk away with?

One real system you built end to end, from a static page to a distributed multi-cloud platform, plus the ADRs, C4 diagrams, and incident write-ups that go with it. You will be able to walk into a design review and explain your choices, the alternatives, and the trade-offs, which is the core of tech-lead and Solution-Architect work.

Is it beginner-friendly?

Yes. Every technical term is explained on first use, in plain English, so you can follow along even if a topic is new. The ramp is gentle and each step builds directly on the last, so you are never dropped into something you have not been shown.

What language is it in?

English and Russian. The same 134 steps in both, written so a beginner can follow either one.

When does it launch?

It is in progress. Join the waitlist and you will be first to hear when it opens, and first in when sign-up goes live.

// join the waitlist

Be first in when it launches.

Leave your email and we will tell you the moment ArchitectPath opens. No spam, one launch email.

Sign up at launch