Is this a system design course in Hindi?

Yes, in Hinglish: technical terms in English, explanations in Hindi the way Indian engineering teams actually talk. It is a live system design course for backend engineers in India, not dubbed English slides. If you searched for a system design course in Hindi or Hinglish, this is built for that.

Is this a developer to architect course?

Yes. The whole arc is developer to architect: one teaching system, earn every split with a reproducible failure, write ADRs for the decisions that matter, and leave with a way of thinking hiring managers can hear. It is not syntax training. We build only what is needed to learn architecture and system design.

Who is this software architecture course for?

People who already build software, not beginners. You should have developed APIs, worked with databases, and shipped apps or services. This cohort is architectural thinking and system design in a structured way. It is not how to write a CRUD API. Sweet spot is mid-to-senior backend engineers who have felt a bad architecture decision in production.

What are the prerequisites?

You should already have developed APIs, worked with databases, and built apps or services. Comfortable cloning a repo, running Docker, and reading a REST contract. This is not for beginners. We do not teach syntax or how to stand up your first service. We teach architectural thinking and system design, in a structured way.

What if I miss a live session?

All sessions are recorded and available to every enrolled student for the cohort duration plus 6 months (watermarked, no public distribution). There is no live coding. The live Q&A and the running demo are where the real learning happens. Try not to miss them.

I work with Java/Node/Python, not .NET. Is this architecture course relevant?

Yes. There is no grade and we do not fail you for C#. Clone the branch, run the demo, follow the decisions. k6 shows up in Week 8, when we load-test. Tadka runs on .NET 10, but service boundaries, API contracts, Kafka, caching, and observability are the same in Java, Node, or Go. Every day ships an option-space.md that maps the pattern to your stack.

Do I need to write C#? Is there live coding? Do you grade us?

No live coding. No grades, no rubric, no homework marks. Tadka is C# in the repo so you can clone and run it. Java, Node, and Go people watch the same demo and write the same kind of decisions. Your job in class is the thinking, not typing handlers.

Do I get a 1:1 mock interview with the instructor?

Everyone does pair mocks in Week 8, plus the Design-Swiggy masterclass. I cannot do forty-five minute 1:1s with fifty people and still teach the cohort. The top five peer-voted ADRs each batch get an instructor review slot.

Will we implement every technology mentioned in the curriculum?

No. We build only what is needed to learn architecture and system design. Postgres, Redis, Kafka, Docker, a bit of observability, k6, and ADRs show up when the teaching system needs them. The week list is the live spine. Break-kits in the repo are optional. MongoDB, Elasticsearch, event sourcing, and fancier deploy patterns come up as trade-offs, not as a second product.

What will I need besides the cohort fee?

Very little. Postgres, Redis, Kafka, and Docker all run free on your laptop. Cloud deploy is one black-box day: we use a pre-built stack and talk about blast radius, release cadence, and the monthly bill. You do not iterate on AWS infra yourself, so no surprise cloud charges.

What's the time commitment per week?

About 5 hours of live sessions on weekends. Clone and run the branch if you want the demo on your laptop. ADRs in class are practice, not a graded assignment. Optional extra time is yours. It is 8 weeks, not a second job.

Do I get a certificate?

You walk out with a way of thinking, the repo, and templates for ADRs, diagrams, and a cost readout. That is what hiring managers hear in a design round, not a PDF that says you completed a course. We do not grade a portfolio for you.

What's the refund policy?

Sit the first live session. If the teaching style is not for you, email before Week 2 and you get 100% back. One class to judge the room, not a week of sampling. No questions asked, no hoops.

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 decisions and defend them with trade-offs, failure modes, and real numbers.

We build only what is needed to learn architecture and system design. Tadka is a teaching system, not a production food-delivery product.

One codebase, Tadka: monolith toward four services and a gateway. No live coding. Class is decisions, diagrams, and running what is already in the repo. Not for beginners: you should already have built APIs, databases, and apps or services.

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 the shape of every decision we write in class. 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). We do not grade your copies.

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.

We write this shape in class: options, trade-offs, what breaks, when to revisit. You can keep a copy for interviews. There is no homework mark and no fail for C#.

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

Names SLOs and traces before you scale, even on a teaching system

Finds a breaking point and a bill, instead of hoping it is fast

The capstone

Tadka: a teaching system, not a production app

We build only what is needed to learn architecture and system design.

One codebase through the architecture arc. Scrub it in the hero above. You clone and run it. You do not build a Swiggy clone from scratch, and there is no live coding.

44 ADRs

The repo documents the major moves. In class we write the seven fields on the board. We do not grade a homework pile.

4 services + gateway

The arc in the repo: monolith toward YARP, Kafka, a local menu replica. Enough to learn the split, not a production estate.

Load test readout

k6 smoke to stress: find the knee on Grafana. Week 8, measured, not guessed.

Cost model + portfolio doc

₹ honest minimal vs built stack, as a teaching readout. A template you can keep. We do not grade it.

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, same class

Run it in .NET or decide in your stack

Tadka ships in C#. There is no live coding and we do not grade you. Class is the same: decisions, diagrams, and a running demo.

.NET track

Clone day-NN branches and run Docker Compose
Repo has the CRUD. Class does not type it with you.
Break-kits with before/after numbers, when that day uses them

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

Not for beginners. You should already have built APIs, databases, and apps or services. Non-.NET people run the same class.

Week by week

8 Weeks of Real Architectural Decisions

Each week builds on the last. Live class is the spine below. The repo has more: break-kits, toys, extra ADRs. We do not teach every file in the five live hours.

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

Week 1 ↔ scrubber Architect the Monolith

Foundation & Domain Modeling

· Developer to architect: ADRs and the four-step, not a new language
· Domain model and schema-per-domain in one Postgres
· Scale numbers you can defend. Tadka runs on your laptop.

Interview layer: The four-step on a real FR/NFR split. Same moves as a round, inside the live class, not a second session.

You can defend starting Tadka as a monolith, with a domain model, schema-per-domain, and rough scale numbers.

Week 2 Architect the Monolith

Monolith API, State Machine & Hardening

· REST contract and errors you can defend (400 / 422 / 404, one shape)
· Server-side price and the order state machine
· Double-tap, lost update, SMS after commit

Interview layer: BookMyShow oversell, using the same xmin you just watched. Folded into Sunday, not extra.

Monolith boundaries are clean enough to split later. Orders survive retries and concurrent writes.

Week 3 ↔ scrubber Architect for Scale

Scaling the Monolith

· When the query dies: index, pool, replica, before you add app boxes
· Redis: cache-aside, and when the cache lies
· Live status without polling

Interview layer: Why a hot key melts you. Same idea as a celebrity restaurant on the menu.

You can explain what breaks at 1 lakh orders/day, and why Redis comes before splitting services.

Week 4 ↔ scrubber Architect for Scale

Modular Monolith & First Service Extraction

· Module boundaries, then extract Payment
· The four questions before you split
· HTTP this week, Kafka next, on purpose

Interview layer: Why Payment split first: fault and PCI, not latency.

You can explain why Payment left the monolith, and why HTTP came before Kafka.

Week 5 ↔ scrubber Architect the Distributed System

Distributed Backbone & Security

· Dual-write, Outbox, saga: one database transaction is no longer enough
· At-least-once delivery, not exactly-once magic
· Auth at the service, not only the gateway

Interview layer: At-least-once plus an idempotent consumer. That is the exactly-once effect.

Kafka, saga, Outbox, and per-service auth make sense on a whiteboard and in the repo.

Week 6 ↔ scrubber Architect the Distributed System

Completing the Service Split & Cloud Deployment

· Restaurant, Delivery, and a gateway. Four services.
· Identity stays a module. Not a fifth service.
· Black-box cloud: bill and blast radius, not Terraform homework

Interview layer: Sunday is the dispatch mock (Uber / Swiggy). That is the class, not a second lecture.

You can tie deployment shape to blast radius, release cadence, and cost.

Week 7 Architect for Production

Observability, Reliability & Failure Thinking

· Traces and SLOs you can actually afford
· Timeouts so one slow call does not take the site down
· Kill Redis or Payment and watch it degrade, not cascade

Interview layer: Hotstar IPL traffic or a feed. Raise the trade-off before they ask.

SLOs and blast radius are things you can argue about, not just dashboard config.

Week 8 ↔ scrubber Architect for Production

Case Studies, Load Testing & Portfolio

· Teardowns: Swiggy, Razorpay. Same problem, different choices.
· k6: find the knee, read the bill
· Portfolio doc you can send a hiring manager

Interview layer: Design-Swiggy masterclass, then pair mocks in class. No scores. This week is interview-heavy on purpose.

You can take Tadka patterns to questions you have never built. Judgment, not a graded portfolio.

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 CRUD is already in the repo on every weekly branch. You clone it. Class is boundaries, contracts, and what breaks.

No live coding. We do not write the app with you in class. We do not walk line by line through FluentValidation or DbContext. You read the repo for that.

Not a production food-delivery product. We build only what is needed to learn architecture and system design.

Not a graded course. There is no rubric, no homework marks, no fail for C#. ADRs in class are practice, not a submission pile.

Not a certification prep course. We focus on how architects think, not exam memorization.

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

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

Not for beginners. You should already have developed APIs, worked with databases, and built apps or services. This is architectural thinking and structured system design, not how to write your first CRUD API.

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

Your Instructor

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 teaching system in this cohort, is one he built the same way he teaches it: write the ADR first, then prove it by breaking the running demo on purpose. You clone it. You do not live-code it.

YouTube 5★ on Topmate LinkedIn

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."

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

₹24,999

40 hours of live sessions (weekends). No live coding.
Tadka teaching repo: clone, run, break. Not a production app you build from scratch.
ADRs written in class. Practice, not a graded pile.
Interview transfer inside the live break. Full mocks from Week 6. Design-Swiggy in Week 8.
Discord community
Session recordings (cohort duration + 6 months, watermarked)

Join the waitlist

First-session refund

Sit the first live class. If the teaching style is not for you, email before Week 2 and you get 100% back.

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. The cohort costs ₹24,999. We will contact you with joining details and any early bird pricing when the batch opens.

No payment needed to join the waitlist. The cohort costs ₹24,999. We'll notify you first when the batch opens, with any early bird pricing. By joining you agree to our privacy policy.

Frequently Asked Questions

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

Most system design and architecture courses give you twenty shallow interview diagrams. We take one teaching system and run the architecture arc: monolith, scale until something hurts, split when the data says so, load test it, break it on purpose. We build only what is needed to learn those moves, not a production food-delivery product. That helps in interviews because you have seen a cache stampede, not just drawn a Kafka box.

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

Monolith + schema-per-domain

Failure to Fix Evidence

Every Decision Gets an ADR

Developer approach vs architect approach

Developer Approach

Architect Approach

Tadka: a teaching system, not a production app

44 ADRs

4 services + gateway

Load test readout

Cost model + portfolio doc

Run it in .NET or decide in your stack

.NET track

Decide track (Java / Node / Go)

8 Weeks of Real Architectural Decisions

Foundation & Domain Modeling

Monolith API, State Machine & Hardening

Scaling the Monolith

Modular Monolith & First Service Extraction

Distributed Backbone & Security

Completing the Service Split & Cloud Deployment

Observability, Reliability & Failure Thinking

Case Studies, Load Testing & Portfolio

What you operate, not just what you draw

What This Cohort Is NOT

Who Is Teaching This

Deepak Mishra

What People Are Saying

Simple pricing

Standard

Join the Waitlist

Frequently Asked Questions

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