Dec Batch · Waitlist Open

Live architecture cohort in Hindi/Hinglish · Real decisions, not diagrams · Weekends in India

Stop Building Like a Developer.
Start Thinking Like an Architect.

After 8 weeks you stop memorising patterns. You make production decisions and defend them with trade-offs, failure modes, and real numbers.

One codebase, Tadka: monolith to four services and a gateway. Break it, measure it, write the ADR. Live weekends for backend engineers.

2mo weekends
40h live
44 ADRs
Join the Waitlist December batch waitlist is open. Seats are limited.

Scrub the evolution

Monolith + schema-per-domain

Week 1

What broke

Baseline: one deployable app, bounded contexts in folders, not five repos on day one.

What we earned

Start as a monolith with schema-per-domain so later extraction is a move, not a rewrite.

14 REST endpoints on /api/v1, order state machine in one transaction.
ADR-002ADR-003ADR-005
Explore the cohort

Measured, not marketed

Failure to Fix Evidence

Every move in the cohort is earned by a reproducible break, then fixed with captured before/after numbers.

Week 2 Correctness ADR-011

Before

Double-tap POST /orders creates two orders and two charges.

Fix

Idempotency-Key: same key returns 200 with the same order id.

Captured

No key: 2 ids. Same key: 201 then 200.

Week 2 Correctness ADR-012

Before

Concurrent PATCH /status: last writer wins, state lost.

Fix

Optimistic concurrency with xmin returns 409 on conflict.

Captured

Two confirms: 204 + 409.

Week 4 Resilience ADR-021ADR-023

Before

Sync payment + slow gateway: POST /orders ~9.2s, pool drains.

Fix

Polly timeout + bulkhead; async payment off the request path.

Captured

9.2s to ~2.1s; POST returns in ms.

Week 5 Resilience ADR-027ADR-028

Before

Payment service down: order pending, charge lost on sync bridge.

Fix

Kafka retains message; Outbox commits event with the order.

Captured

Lag 1, restart, Confirmed, lag 0.

Week 6 Scale ADR-037

Before

Restaurant down on sync HTTP read: order hot path fails.

Fix

Event-carried menu replica in ordering schema.

Captured

Restaurant down: order still 201, priced at 598 INR.

Week 7 Ops ADR-040ADR-041

Before

Order stuck: grep five uncorrelated log streams.

Fix

traceparent on HTTP, outbox row, and Kafka consume.

Captured

One Jaeger trace: 9 spans across 4 services.

Week 7 Resilience ADR-043

Before

Flaky payment gateway: retries hang for seconds.

Fix

Circuit breaker on Payment to gateway; transport-only retry.

Captured

OPEN: fail-fast ms. Recover: 698 INR order completes.

Week 8 Ops ADR-039

Before

Boxes on a slide with no monthly bill attached.

Fix

Cost model: honest minimal vs built isolation at 1 lakh/day.

Captured

~6,100 INR minimal vs ~31,300 INR built (~5x).

Week 6 Correctness ADR-045

Before

Restaurant rejects after payment settles: order Cancelled, charge stays Completed.

Fix

Compensating Saga: refund-requested Outbox event, both choreography and orchestration modes.

Captured

Refund off: money stuck. Refund on: Cancelled + Refunded. Both saga modes: identical 10-span trace.

Week 6 Ops ADR-061

Before

A new Restaurant release deploys to 100% of traffic at once; a bug takes down every order.

Fix

Weighted canary at the gateway: hold a bad release to a small percentage, compare telemetry, roll back with a config flip.

Captured

Error rate tracks the configured weight (5/25/100%); rollback to 0% is instant, no redeploy.

Week 7 Resilience ADR-059

Before

Concurrent requests queue until every thread and DB connection is burned.

Fix

Admission control: a zero-wait semaphore rejects excess concurrent requests immediately (429), never queues.

Captured

MaxConcurrent=3 + 15 concurrent requests: exactly 3x 201, rest 429 with Retry-After.

Week 8 Ops ADR-059ADR-060

Before

A capstone chaos drill that only works if a human manually restarts services at the right moments.

Fix

Self-contained timed cascade: the script itself restarts Payment.Api and starts load, then stops Redis, then Kafka, then recovers.

Captured

T+0 Payment Slow, T+2m load, T+4m Redis down, T+6m Kafka down, full automatic recovery after.

How we teach

Every Decision Gets an ADR

This is what you submit every week. Hiring managers care about this more than a certificate line on LinkedIn. A real decision from Week 5 of Tadka (ADR-028: Transactional Outbox + Inbox).

ADR-028Transactional Outbox + InboxWeek 5 · Kafka backbone
Topic

How do we publish order events to Kafka without losing messages or double-charging?

Options

Direct dual-write (DB + Kafka), Kafka transactions (EOS), Transactional Outbox + Inbox, or CDC/Debezium

Choice

Transactional Outbox on the producer, Inbox on the consumer.

Why

Write the event into an outbox row in the same Postgres transaction as the order. One commit, both land or neither. A relay publishes to Kafka. Consumers deduplicate via an inbox table. You get exactly-once effect on at-least-once delivery.

Trade-off

More moving parts: outbox table, relay loop, inbox per consumer. Polling adds a little latency. But it is just code and two small tables. No new infra beyond Kafka.

Failure mode

Dual-write loses events on crash between DB commit and Kafka publish (Day 8 wound). Naive consumer double-charges on Kafka redelivery. Relay without SKIP LOCKED double-publishes when scaled to N pods.

Revisit when

At high volume, swap the polling relay for CDC (Debezium) or a library outbox like MassTransit. Add a DLQ when you hit a real poison message.

You write one of these every week. We grade the reasoning, the alternatives you considered, what breaks, and proof you ran the demo. Not whether your C# compiles.

61 decisions across 8 weeks

Full index ships in the Tadka repo. Below: one headline per week.

See week-by-week curriculum →
Week 13 ADRs

Monolith foundation

  • ADR-002 · monolith-first
  • ADR-003 · schema-per-domain
Week 211 ADRs

API + hardening

  • ADR-011 · idempotency
  • ADR-012 · optimistic concurrency
  • ADR-056 · pessimistic locking (hot-row coupons)
Week 35 ADRs

Scale the database

  • ADR-014 · indexing strategy
  • ADR-016 · read replica + split
  • ADR-057 · keyset cursor pagination
Week 411 ADRs

Cache + payment brownout

  • ADR-021 · timeout + bulkhead
  • ADR-023 · async payment
  • ADR-049 · distributed rate limiting
Week 513 ADRs

Kafka, security, extraction

  • ADR-028 · Outbox + Inbox
  • ADR-029 · saga choreography
  • ADR-052 · field-level PII encryption
Week 611 ADRs

4 services + gateway

  • ADR-035 · API gateway YARP
  • ADR-037 · event-carried read model
  • ADR-061 · gateway weighted canary
Week 77 ADRs

Observability + resilience

  • ADR-040 · OpenTelemetry
  • ADR-043 · circuit breaker
  • ADR-059 · backpressure admission control
Week 8portfolio week

Portfolio + load test

Load test readout, cost model, architecture portfolio.

The shift

Developer approach vs architect approach

Most engineers keep shipping features. Architects argue about what breaks at 10x and what that costs.

Developer Approach

Picks the tech stack on Day 1 based on hype
Builds features first, writes docs never
One database for everything, figures it out later
Deploys on Friday evening and prays over the weekend
Adds monitoring after the first production outage
"It works on my machine" is the final test

Architect Approach

Writes down NFRs first, then picks tech deliberately
Writes Architecture Decision Records (ADRs) before writing code
Picks storage per operation. One Postgres until the data shape forces a split.
Knows when blue-green is worth the money and when it is theatre at your scale
SLO dashboards, distributed tracing, and alerts configured before launch
Load tests to 1 lakh orders/day, chaos testing, and FinOps cost modeling

The capstone

Tadka: Bangalore food delivery, built for real

One system start to finish. Scrub the architecture arc in the hero above. Week 8 you ship artifacts you can defend in a design review.

44 ADRs

Every major move documented: options, trade-offs, failure modes, revisit triggers.

4 services + gateway

Monolith to YARP :8080, Kafka saga, local menu replica, database-per-service.

Load test readout

k6 smoke → stress knee on the Day-13 Grafana dashboards. Breaking point measured, not guessed.

Cost model + portfolio doc

₹ honest minimal vs built stack. architecture.md is the piece you send to hiring managers.

Built with

The demo is .NET. The thinking works in Java, Go, or Node too.

.NET 10 PostgreSQL Redis Kafka YARP Gateway Docker OpenTelemetry Grafana k6

Two tracks, one rubric

Build in .NET or decide in your stack

Tadka ships in C#. We grade ADRs, diagrams, failure analysis, and demo evidence, not whether your handlers compile.

Build track (.NET)

  • Clone day-NN branches and run Docker Compose
  • Touch glue code in class; repo has the boring CRUD
  • Break-kits with before/after numbers

Decide track (Java / Node / Go)

  • Black-box Docker: observe contracts, lag, traces, dashboards
  • Weekly option-space.md maps patterns to your stack
  • Weeks 6 to 8: watch Grafana and Jaeger, write the ADR; skip EF, YARP, and k6 authoring

Best fit: 5 to 12 years of backend scars. Non-.NET onboarding is in the cohort Phase 0 package.

AI-powered

The architect's AI toolkit

We standardize on GitHub Copilot so you are not juggling five subscriptions. Configured for architecture work, not autocomplete spam.

GitHub Copilot

One tool, fully configured for architecture work

📐

Custom Instructions

Custom instructions so Copilot questions your trade-offs, not just your bracket placement.

🤖

Agent Mode

Scaffold the boring parts fast: service skeletons, migrations, boilerplate you would otherwise type by hand.

🧠

Skills & copilot-instructions.md

Project context baked in: ADRs, scale targets, constraints. Suggestions stay on brief instead of random Stack Overflow paste.

Prefer the terminal? Week 1 also covers Claude Code if you think faster at the shell. Pick one tool. The ADR discipline stays the same.

Week by week

8 Weeks of Real Architectural Decisions

Each week builds on the last. Nothing is there to pad a syllabus. Every Saturday/Sunday ends with a short interview drill using the same moves as a full 45-minute round.

Weeks with a scrubber milestone sync with the hero explorer above.

Week 1 ↔ scrubber Architect the Monolith

Foundation & Domain Modeling

  • · Developer to architect: what actually changes. Patterns matter, not whether you write Java or C#.
  • · Requirements: functional vs non-functional, plus back-of-envelope math for Tadka traffic and storage
  • · ADRs and the four-step framework we reuse in every interview round
  • · DDD basics: bounded contexts, aggregates, schema-per-domain. Code boundaries now, service boundaries later.
  • · Diagrams another engineer can read. AI helps you think faster; it does not make the call.
Interview layer: I solve a notification system live in class. You watch the same six moves you would use in a 45-minute round.
You can defend starting Tadka as a monolith, with a domain model, schema-per-domain, and rough scale numbers. Tadka runs on your laptop.
Week 2 Architect the Monolith

Monolith API, State Machine & Hardening

  • · API-first contracts: REST shapes, versioning trade-offs, RFC 7807 errors
  • · Order state machine: legal transitions in code, illegal ones return 422
  • · Full order lifecycle in one app, one database, one transaction
  • · Failure-first hardening: idempotency keys, optimistic concurrency, in-process domain events
  • · Workshop: API versioning and state-machine exercises
Interview layer: Booking / flash-sale drill (BookMyShow, Tatkal): seat locking, fairness, oversell. Uses this week's state machine work.
Monolith boundaries are clean enough to split later. Orders survive retries and concurrent writes.
Week 3 ↔ scrubber Architect for Scale

Scaling the Monolith

  • · Postgres in anger: indexing, EXPLAIN ANALYZE, read replicas, connection pools
  • · Partitioning vs sharding: consistent hashing, and what changes between 1 lakh and 1 crore orders/day
  • · Redis: cache-aside, stampede locks, TTLs, when the cache lies to you
  • · CAP in practice: which Tadka features need strong consistency and which can relax
  • · Pick a cache invalidation strategy from four real options
  • · Live order tracking: SSE over a Redis pub/sub backplane. Push, not poll, and it works across instances.
Interview layer: Pair drill: URL shortener or rate limiter. Cache as the product, token bucket, consistent hashing.
You can explain what breaks at 1 lakh orders/day, why Redis comes before splitting services, and why SSE beats polling for live status.
Week 4 ↔ scrubber Architect for Scale

Modular Monolith & First Service Extraction

  • · Modular monolith: MediatR domain events, module boundaries, vertical slices
  • · When to extract a service: scaling, team ownership, deploy cadence, compliance
  • · First split: Payment over HTTP (Kafka comes next week, for a reason)
  • · Architecture review: find the flaws in a deliberately broken diagram
  • · Why event-driven architecture shows up now and not in week one
Interview layer: Pair drill: design a payment system. Idempotency, ledger, saga, reconciliation.
You can explain why Payment split first (fault and PCI isolation, not latency) and why HTTP came before Kafka.
Week 5 ↔ scrubber Architect the Distributed System

Distributed Backbone & Security

  • · Sagas: why one database transaction is no longer enough
  • · Idempotency and dedup: why "exactly once" is harder than the blog posts say
  • · Transactional Outbox + Inbox, event schema versioning
  • · JWT auth and RBAC with resource ownership, checked in every service
  • · PII, GDPR delete requests, PCI scope: classify data before you store it
Interview layer: Pair drill: chat system (WhatsApp). Fan-out, ordering, delivery receipts, dedup.
Kafka + Saga + Outbox + per-service auth make sense on a whiteboard and in the repo. Delivery and the gateway land next week.
Week 6 ↔ scrubber Architect the Distributed System

Completing the Service Split & Cloud Deployment

  • · Last extractions: Restaurant and Delivery. Four services plus a gateway.
  • · Progressive delivery: feature flags and weighted canary rollout, and why a naive rename breaks the running old version
  • · Zero-downtime migrations: expand-contract, then the ugly part: backfilling millions of rows without locking prod or killing replication
  • · Deploy day: pre-built cloud stack, all four services live. We read the bill and the blast radius, not Terraform syntax.
  • · What actually matters in deploy: ALB routing, ECS vs Lambda vs K8s, network hops, monthly cost
  • · Cost model walkthrough: what each architectural choice does to the AWS invoice (modeled, not charged to you)
Interview layer: First full 60-minute mock: Uber / Swiggy dispatch. Geo index, nearest riders, live location, surge.
You can tie deployment shape to blast radius, release cadence, and cost. All four services plus gateway running in cloud.
Week 7 Architect for Production

Observability, Reliability & Failure Thinking

  • · Logs, metrics, traces across every service
  • · Pick an observability stack with real pricing constraints
  • · Set your own SLOs before you see ours (most people aim too high)
  • · Circuit breakers, retries, timeouts, bulkheads
  • · Chaos live: kill Redis or Payment, watch graceful degradation, not a cascade
  • · Backpressure and load shedding when traffic spikes
  • · Failure mode analysis: for every arrow in the diagram, what breaks and who gets paged?
Interview layer: Mock: Hotstar IPL traffic or Instagram feed. Plus a session on driving the interview room and raising trade-offs without being asked.
SLOs, blast radius, and load shedding are things you can argue about, not just dashboard config.
Week 8 ↔ scrubber Architect for Production

Case Studies, Load Testing & Portfolio

  • · Teardowns: Swiggy, Zomato, Razorpay. Same problems, different choices.
  • · Apply Tadka patterns to problems you have never built
  • · k6 load tests plus AWS cost modeling: find the knee, read the bill
  • · If you started a startup tomorrow: your first three architectural decisions
  • · Final portfolio doc and interview pack
Interview layer: Design-Swiggy masterclass, then final mocks scored with the cohort rubric.
You can take patterns from Tadka to unfamiliar interview questions. Portfolio shows judgment, not just repos.

Week 7–8 instruments

What you operate, not just what you draw

Traces, bills, and breaker state. The same panels we use when Tadka breaks on purpose.

Jaeger trace waterfall: 9 spans across 4 services for one order saga

Payment=Failing → trace ends at Payment (7 spans, no Delivery). Same dashboards in class.

What This Cohort Is NOT

Honest expectations before you commit your time and money.

Not a syntax bootcamp. The boring CRUD is already in the repo on every weekly branch. You clone it. In class we touch the interesting parts: Outbox, circuit breakers, trace propagation. Most of your grade is ADRs and diagrams, not C#.

Not a live-typing show. We do not walk line by line through FluentValidation or DbContext. You read the repo for that. Class time goes to boundaries, contracts, and what breaks.

Not a passive video series. You will build, deploy, and write ADRs.

Not a certification prep course. We focus on real-world engineering, not exam memorization.

Not a high-level summary of 28 random systems. We go deep into ONE production architecture.

Not a tool checklist. MongoDB, Elasticsearch, Event Sourcing, and blue-green deployment are discussed as trade-offs, not forced into the build.

Not for freshers. You need to have shipped something to production and felt the cost of a decision made without enough thinking, whether that was 4 years in or 18.

Not a course where you install Kafka on day one because the syllabus said so. Each tool shows up when the system actually needs it.

Your Instructor

Who Is Teaching This

Deepak Mishra, The Desi Architect

Deepak Mishra

The Desi Architect · Software Architect, 12+ years

Started from a non-CS background and learned the hard way, through real systems, real outages, and real design reviews. Today he architects distributed systems and AI products for enterprise and SaaS clients used by millions.

Tadka, the capstone you build in this cohort, is a system he built end to end the same way he teaches it: write the ADR first, then prove it by breaking the system on purpose.

Testimonials

What People Are Saying

Real feedback from mentees and the YouTube community.

"One of the most valuable career conversations I've had. He didn't give me a generic roadmap. He listened, understood my exact situation, and gave me a clear, practical direction I could act on immediately. The focus on fundamentals first, and knowing WHEN to use something rather than just HOW, completely shifted my thinking."

SA

Shaad Ansari

Mentee via Topmate

"I'm currently transitioning into an Architect role, and this is the only YouTube channel I've found that truly focuses on that path. I discovered The Desi Architect about 3-4 weeks ago, watched all the videos, and have been eagerly waiting for new content. Finally, the wait is over!"

MS

Mahesh Singh

YouTube viewer

"Deepak is a highly experienced architect and mentor. I absolutely enjoyed system design and architectural discussion with him."

TM

Topmate review

5★ review, May 2026

"I am aspiring to be an architect in future and this video really helped open my eyes and give me real life insights about software architecture."

RK

Rahul K

YouTube viewer

"Very clear system thinking, I am thankful to see this video exactly when I am not clear how to move to next level."

NK

Nikhil Koranne

YouTube viewer

"Excellent Explanation, Flow is too good, and the examples are mind blowing (simple & clean). Keep it up!"

BK

Bharat Kedia

YouTube viewer

Investment

Simple pricing

No hidden fees. No upsells. You pay once, you get everything.

Standard

Standard pricing applies to regular registrations

₹24,999
  • 40 hours of live sessions (weekends)
  • Full Tadka capstone project access
  • Architecture portfolio document
  • Architecture Decision Records (ADRs) for every major decision
  • Weekly interview drills plus the Design-Swiggy masterclass
  • Pair mock interviews in Week 8
  • AI pair-programming workflow (GitHub Copilot or Claude Code)
  • Discord community (lifetime access)
  • Session recordings (cohort duration + 6 months, watermarked)
Join the waitlist

7-Day Full Refund Guarantee

If the first week doesn't convince you, you get 100% back. No questions asked.

Dec Batch · Waitlist Open

Join the Waitlist

Join the December batch waitlist. Seats are limited, so if you are serious about the cohort, sign up below. We will contact you with joining details and early bird pricing when the batch opens.

Sign in with your Google account to join the waitlist.

No payment needed. We'll notify you first when the batch opens. By joining you agree to our privacy policy.

Frequently Asked Questions

Common questions about the cohort, the curriculum, and who should join.