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.
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.
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.
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.
Before
Concurrent PATCH /status: last writer wins, state lost.
Fix
Optimistic concurrency with xmin returns 409 on conflict.
Captured
Two confirms: 204 + 409.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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).
How do we publish order events to Kafka without losing messages or double-charging?
Direct dual-write (DB + Kafka), Kafka transactions (EOS), Transactional Outbox + Inbox, or CDC/Debezium
Transactional Outbox on the producer, Inbox on the consumer.
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.
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.
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.
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.
Monolith foundation
- ADR-002 · monolith-first
- ADR-003 · schema-per-domain
API + hardening
- ADR-011 · idempotency
- ADR-012 · optimistic concurrency
- ADR-056 · pessimistic locking (hot-row coupons)
Scale the database
- ADR-014 · indexing strategy
- ADR-016 · read replica + split
- ADR-057 · keyset cursor pagination
Cache + payment brownout
- ADR-021 · timeout + bulkhead
- ADR-023 · async payment
- ADR-049 · distributed rate limiting
Kafka, security, extraction
- ADR-028 · Outbox + Inbox
- ADR-029 · saga choreography
- ADR-052 · field-level PII encryption
4 services + gateway
- ADR-035 · API gateway YARP
- ADR-037 · event-carried read model
- ADR-061 · gateway weighted canary
Observability + resilience
- ADR-040 · OpenTelemetry
- ADR-043 · circuit breaker
- ADR-059 · backpressure admission control
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
Architect Approach
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.
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-NNbranches 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.mdmaps 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.
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.
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.
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
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.
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
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
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)
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?
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
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.
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.
Who Is Teaching This

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.
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."
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!"
Mahesh Singh
YouTube viewer
"Deepak is a highly experienced architect and mentor. I absolutely enjoyed system design and architectural discussion with him."
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."
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."
Nikhil Koranne
YouTube viewer
"Excellent Explanation, Flow is too good, and the examples are mind blowing (simple & clean). Keep it up!"
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
- 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)
7-Day Full Refund Guarantee
If the first week doesn't convince you, you get 100% back. No questions asked.
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.