Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews
Microservices Mastery
A comprehensive, interview-focused curriculum designed for engineers targeting Senior/Staff roles at top tech companies (Google, Amazon, Netflix, Uber, Stripe, etc.). This course covers everything from microservices fundamentals to production-ready distributed systems.
Course Duration: 16-20 weeks (self-paced) Target Outcome: Senior+ Engineer at FAANG / Top-tier microservices expertise Prerequisites: Node.js or Python basics, REST APIs, basic database knowledge Languages: Every code example is shown in both Node.js/TypeScript and Python so you can learn in the stack you use at work Projects: 10+ hands-on projects including a full e-commerce platform Chapters: 27 in-depth chapters covering all aspects of microservices
Why This Course?
Interview Ready
Covers exact topics asked at top tech companies for backend/distributed systems roles
Production Patterns
Real patterns from systems handling millions of requests at Netflix, Uber, Amazon
Hands-On Projects
Build a complete e-commerce platform with 10+ microservices
Deep Technical Foundation
Understand the “why” behind every pattern, not just the “how”
Interview Reality: At Senior+ level, you’re expected to design microservices systems that handle millions of requests, maintain data consistency, and recover from failures gracefully. This course prepares you for exactly that.
Before You Begin: Organizational Readiness
Before you write a single docker-compose.yml, stop and check whether your organization is ready. The most expensive microservices mistakes are not technical — they are organizational. Teams adopt microservices because they read about Netflix or Amazon, not because their own context calls for it. The result is a distributed monolith with twice the operational cost and half the velocity of what they had before.
Caveats & Common Pitfalls — Jumping to Microservices Without Org Readiness
Teams adopt microservices before they can deploy reliably. If your current monolith takes 2 hours to deploy manually and rollback requires a Slack thread of 6 engineers, splitting into 12 services will make every deploy exponentially more painful. You need mature CI/CD, container orchestration, and observability before decomposition, not as a bonus goal.
Engineers mistake microservices for modularity. A well-structured modular monolith gives you 80% of the boundary benefits with 10% of the operational tax. If your pain is “code is tangled,” the answer is module boundaries and architectural tests, not a network hop.
Leadership pushes microservices for resume-driven reasons. “Our CTO wants microservices” is not a requirement; it is a preference. Convert it to measurable goals (deploy frequency, team independence, scaling granularity) and check whether monolith improvements could hit those goals first.
Conway’s Law is treated as a suggestion, not a law. If you have four functional teams (frontend, backend, database, QA), you will produce a four-tier architecture, regardless of the microservices diagram on the wall. The org chart wins every time.
Solutions & Patterns — The Org Readiness ChecklistBefore extracting your first service, verify these six prerequisites. This is the “readiness checklist” that Martin Fowler and Sam Newman both cite as a minimum bar.Decision rule: If you cannot confidently check all six, your next investment should be in the gap — not in extracting services.
Rapid provisioning — You can spin up a new environment (DB, runtime, load balancer) in under 30 minutes via automation.
Basic monitoring — You have structured logs, metrics, and at least one shared dashboard; you can answer “is service X healthy?” without SSH.
Rapid deployment — You can deploy a single service to production without a human approval chain longer than 15 minutes.
DevOps culture — Developers own deployment, not a separate ops team who “releases” code.
Explicit domain boundaries — At least one Event Storming session has produced a context map that the whole team agrees on.
Team autonomy — Teams can make technical choices (framework, DB, language) without a central architecture review board blocking each decision.
Before/after example: A fintech team I worked with wanted to split their 400K-LOC Rails monolith into 20 services. They had manual deploys, one shared Postgres, and no distributed tracing. Before readiness work: 14 months of pain projected. After investing 4 months in CI/CD, tracing, and a modular-monolith refactor: they extracted the first service (fraud scoring) in 6 weeks with zero production incidents. The readiness work paid for itself before service #2.
Interview: A VP of Engineering asks you 'Why shouldn't we just adopt microservices now so we're ready when we grow?' How do you respond?
Strong Answer Framework:
Reframe the question from “when” to “why.” Microservices are not an upgrade path — they are a different set of trade-offs. Ask what specific problems they are trying to solve.
Quantify the current pain. Deploy frequency, failed deploys, onboarding time, cross-team blockers. If these numbers are fine, the VP is optimizing for a future problem.
Calculate the distributed-systems tax. Roughly 30-40% of engineering capacity goes to infrastructure for the first year post-migration.
Propose the modular monolith as a bridge. You get boundary discipline, separate schemas, and architectural tests without the network hop. Extract later when the pain is real.
Agree on explicit triggers for extraction. “When deploy coordination costs exceed X hours/week per team” beats “when we’re bigger.”
Real-World Example:Segment (2017-2018). Segment famously moved from a monolith to microservices, then back to a monolith. With about 100 engineers, their fine-grained services (150+ at peak) meant a single event crossed 15+ services, and debugging consumed more engineering time than feature work. They consolidated back, and their 2020 blog post became the canonical cautionary tale for premature decomposition.Senior Follow-up Questions:
“What metrics would prove to the VP that microservices are working?” Deploy frequency per team, change failure rate, mean time to recovery, and team-independence index (how often does team A block team B on a deploy?).
“How would you handle a direct order to proceed anyway?” Propose a pilot: extract one service, run it for one quarter, and measure the metrics above. If they improve, continue. If not, pause.
“What’s the cheapest experiment that de-risks the decision?” Run a two-week modular-monolith spike: introduce strict module boundaries with architectural tests and see if the deploy coupling pain drops. If it does, you may not need microservices at all.
Common Wrong Answers:
“Sure, let’s start extracting services next sprint.” Fails because it skips the readiness audit and the org analysis. You will end up with a distributed monolith.
“Microservices are always better at scale; we should migrate.” Fails because it treats microservices as universally superior. Shopify, Basecamp, and Stack Overflow all run successful monoliths at scale.
Further Reading:
Martin Fowler, “Microservice Prerequisites” — the canonical readiness checklist.
Sam Newman, “Monolith to Microservices” (O’Reilly, 2019) — when and how to extract.
Segment’s “Goodbye Microservices” blog post (2018) — the pivot-back story in detail.
Interview: 'When would you tell a team microservices would hurt more than help?' Give me your explicit decision criteria.
Strong Answer Framework:
Team size under 15-20 engineers. Operational overhead per service is roughly constant; fixed costs swamp small teams.
Unclear or unstable domain boundaries. If you cannot name the contexts, extraction will freeze the wrong lines into APIs.
Strong consistency requirements across most workflows. If 70% of your flows need ACID across domains, distributed sagas will hurt every feature.
Limited DevOps maturity. No CI/CD, no observability, manual deploys — microservices will amplify these weaknesses.
MVP or rapid-pivot stage. You need to change data models weekly; API contracts slow you down.
Uniform scaling profile. If every part of the system scales together, you gain nothing by scaling independently.
Real-World Example:Istio itself (2017-2019). Istio, the service mesh, initially shipped as a set of microservices (Pilot, Mixer, Citadel, Galley). By 2020 they consolidated back into a single binary called istiod. Reason: the microservices pattern added operational pain for users without buying internal development velocity, because a small team owned all four components.Senior Follow-up Questions:
“What about a 10-person team building a real-time trading platform?” Still probably a monolith, because latency budgets are tight and network hops are measurable. Extract only the pieces with truly different scaling profiles.
“You said ‘strong consistency across domains kills microservices’ — but Amazon uses microservices for orders and payments.” Amazon uses saga patterns with idempotent compensations, and they accept eventual consistency on non-critical paths. They invested a decade of platform engineering to make that cheap — it is not cheap for most teams.
“How do you spot ‘unclear domain boundaries’ early?” Run Event Storming. If the domain experts disagree on basic vocabulary (“is a customer the same as a user?”), freeze extraction until the business model clarifies.
Common Wrong Answers:
“Microservices are always right once you’re big enough.” Size is necessary but not sufficient. Basecamp (37signals) has stayed monolithic at scale by choice.
“You should extract when the codebase hits X lines of code.” LOC is a terrible metric. Coupling and team friction are the real signals.
Further Reading:
Google’s Istio v1 -> istiod consolidation blog (2020).
DHH, “The Majestic Monolith” — Basecamp’s explicit anti-microservices position.
Matt Klein (Envoy creator), “Microservices: A Retrospective” on why service meshes should not themselves be mesh-of-services.
Interview: Your team of 8 engineers has a 300K-LOC monolith and leadership wants to break it into 20 services in 6 months. What do you recommend?
Strong Answer Framework:
Push back on the timeline, not the goal. 20 services in 6 months with 8 engineers is a recipe for a distributed monolith. Propose extracting 1-2 services and reassessing.
Audit readiness first (2-4 weeks). CI/CD, observability, deployment automation. Fix gaps before extracting.
Identify the highest-pain boundary. Which module causes the most merge conflicts, has the most distinct scaling needs, or requires the most cross-team coordination? That is extraction #1.
Use the Strangler Fig pattern. Route new traffic to the new service behind the existing API gateway. Old code path remains until the new service is proven.
Define success metrics explicitly. Deploy frequency for the extracted service, number of cross-service incidents, team velocity changes.
Plan to stop. Commit to not extracting service #3 until #1 and #2 are fully stable.
Real-World Example:Shopify (2016-present). Despite serving millions of merchants, Shopify runs what they call the “majestic modular monolith” in Ruby. When they extract services, they do it surgically — for example, their Storefront Renderer was extracted specifically because its caching profile was dramatically different from admin. They did not set out to have “X services” — they set out to solve a specific scaling problem per extraction.Senior Follow-up Questions:
“What if leadership insists on all 20?” Present the risk in business terms: projected production incident rate, feature velocity drop, time-to-recovery projections. Offer a 3-month checkpoint with explicit kill criteria.
“How do you pick extraction #1?” Two factors: highest current pain (pick the module causing the most friction) and lowest coupling to the rest (pick something with a clean data boundary). You want an early win that builds confidence.
“What’s the sign you should stop extracting?” When cross-service debugging starts costing more engineering hours than the benefits of independence provide. Measure this explicitly.
Common Wrong Answers:
“Yes, we can do 20 services in 6 months if we hire contractors.” Staffing up mid-migration multiplies coordination cost. You will end with more services and less expertise per service.
“Let’s do a big-bang rewrite.” Historically, rewrites from monolith to microservices-at-once have a failure rate above 70% (per DORA research). Incremental extraction is the only safe path.
Further Reading:
Shopify Engineering blog, “Deconstructing the Monolith” (2019).
Sam Newman, “Building Microservices” 2nd edition, Chapter 3 (Strangler Fig).
DORA Accelerate State of DevOps reports on rewrite failure rates.
What Companies Ask
Company
Common Microservices Topics
Amazon
Service decomposition, eventual consistency, DynamoDB patterns, SQS/SNS
Netflix
Circuit breakers, chaos engineering, service mesh, Eureka
gRPC, service discovery, load balancing, observability
Meta
Graph services, fan-out patterns, caching at scale
Complete Curriculum
#
Chapter
Topics
00
Overview
Course structure, learning path, prerequisites
01
Foundations
Monolith vs microservices, when to use, trade-offs
02
Domain-Driven Design
Bounded contexts, aggregates, service decomposition
03
Sync Communication
REST, gRPC, protocol buffers, API versioning
04
Async Communication
Message queues, RabbitMQ, Kafka, event-driven
05
API Gateway
Routing, authentication, rate limiting, Kong
06
Data Management
Database per service, saga pattern, CQRS
07
Resilience Patterns
Circuit breaker, retry, bulkhead, timeout
08
Service Discovery
Consul, Eureka, DNS-based discovery
09
Observability
Tracing, logging, metrics, Prometheus, Jaeger
10
Security
OAuth2, JWT, mTLS, secrets management
11
Containerization
Docker, multi-stage builds, best practices
12
Kubernetes
Deployments, services, ConfigMaps, scaling
13
Testing
Unit, integration, contract, E2E testing
14
Interview Prep
Common questions, system design, coding
15
Capstone Project
E-commerce platform with 10+ services
16
Service Mesh
Istio, Linkerd, traffic management, mTLS
17
Configuration Management
Consul, feature flags, hot reload
18
CI/CD
GitOps, ArgoCD, GitHub Actions, canary deploys
19
Database Patterns
Data partitioning, migrations, replication
20
Caching Strategies
Redis, cache-aside, invalidation, distributed
21
Chaos Engineering
Chaos Monkey, LitmusChaos, game days
22
Case Studies
Netflix, Uber, Amazon, Spotify architectures
23
Load Balancing
Client/server-side, algorithms, health checks
24
Migration Patterns
Strangler fig, branch by abstraction, CDC
25
Event Sourcing Deep Dive
Event stores, projections, snapshots
26
GraphQL Federation
Apollo Federation, schema composition
Course Structure
The curriculum is organized into 10 tracks progressing from fundamentals to Staff+ expertise:
┌─────────────────────────────────────────────────────────────────────────────┐│ MICROSERVICES MASTERY │├─────────────────────────────────────────────────────────────────────────────┤│ ││ TRACK 1: FOUNDATIONS TRACK 2: COMMUNICATION ││ ───────────────────── ──────────────────────── ││ ☑ Monolith vs Microservices ☑ Synchronous (REST/gRPC) ││ ☑ Domain-Driven Design ☑ Asynchronous (Message Queues) ││ ☑ Service Decomposition ☑ Event-Driven Architecture ││ ☑ API Design Principles ☑ API Gateway Patterns ││ ☑ Database per Service ☑ GraphQL Federation ││ ││ TRACK 3: DATA MANAGEMENT TRACK 4: RESILIENCE ││ ───────────────────────── ────────────────────── ││ ☑ Database per Service ☑ Circuit Breaker Pattern ││ ☑ Saga Pattern ☑ Retry Strategies ││ ☑ Event Sourcing ☑ Bulkhead Isolation ││ ☑ CQRS Pattern ☑ Timeout Patterns ││ ☑ Caching Strategies ☑ Chaos Engineering ││ ││ TRACK 5: DEPLOYMENT TRACK 6: OBSERVABILITY ││ ───────────────────── ──────────────────────── ││ ☑ Containerization ☑ Distributed Tracing ││ ☑ Kubernetes Basics ☑ Centralized Logging ││ ☑ Service Discovery ☑ Metrics & Dashboards ││ ☑ Service Mesh (Istio) ☑ Health Checks ││ ☑ CI/CD Pipelines ☑ Alerting Systems ││ ││ TRACK 7: SECURITY TRACK 8: ADVANCED PATTERNS ││ ───────────────────── ──────────────────────────── ││ ☑ Service-to-Service Auth ☑ Strangler Fig Pattern ││ ☑ API Gateway Security ☑ Backend for Frontend (BFF) ││ ☑ Secrets Management ☑ Sidecar Pattern ││ ☑ Zero Trust Architecture ☑ Ambassador Pattern ││ ☑ Rate Limiting & Throttling ☑ Migration Patterns ││ ││ TRACK 9: REAL-WORLD TRACK 10: INTERVIEW PREP ││ ───────────────────── ──────────────────────── ││ ☑ Netflix Architecture ☑ System Design Questions ││ ☑ Uber Dispatch System ☑ Coding Challenges ││ ☑ Amazon SOA Journey ☑ Behavioral Questions ││ ☑ Spotify Squad Model ☑ Architecture Deep Dives ││ ☑ Configuration Management ☑ Capstone Project ││ ││ ═══════════════════════════════════════════════════════════════════════════││ CAPSTONE PROJECT: E-COMMERCE PLATFORM ││ ───────────────────────────────────── ││ □ User Service □ Order Service □ Inventory Service ││ □ Payment Service □ Notification Service □ Search Service ││ □ API Gateway □ Event Bus (Kafka) □ Full Observability ││ │└─────────────────────────────────────────────────────────────────────────────┘
Learning Path
1
Foundations (Week 1-2)
Understand when and why to use microservices. Learn DDD and service decomposition strategies.
2
Communication Patterns (Week 3-4)
Master sync/async communication, event-driven architecture, and API gateway patterns.
3
Data Management (Week 5-6)
Handle distributed data with sagas, event sourcing, CQRS, and caching strategies.
4
Resilience Patterns (Week 7-8)
Build fault-tolerant services with circuit breakers, retries, bulkheads, and chaos engineering.
5
Deployment & DevOps (Week 9-10)
Deploy with Docker, Kubernetes, service mesh, and implement CI/CD pipelines.
6
Observability (Week 11-12)
Implement distributed tracing, logging, metrics, and comprehensive monitoring.
7
Security & Advanced (Week 13-14)
Secure your services and learn advanced architectural patterns including migration strategies.
8
Case Studies (Week 15-16)
Learn from Netflix, Uber, Amazon, and Spotify architectures. Understand real-world trade-offs.
9
GraphQL & Event Sourcing (Week 17-18)
Master GraphQL Federation and deep dive into event sourcing patterns.
10
Capstone Project (Week 19-20)
Build a production-ready e-commerce platform with 10+ services.
Conway’s Law as a Warning, Not a Tattoo
Every course on microservices mentions Conway’s Law. Most treat it as an inspirational quote. It is not. It is a load-bearing constraint on your architecture, and ignoring it is the fastest way to a distributed monolith.
Caveats & Common Pitfalls — The Conway Traps
The “diagram first, org last” trap. Architects draw a beautiful service mesh diagram, hand it to a functionally-organized engineering department, and expect the diagram to materialize. Six months later the “microservices” share databases and require cross-team tickets for every change. The org chart won.
The shared-ownership trap. “This service is owned by the platform team and the payments team” means it is owned by nobody. On-call gaps, slow decisions, and conflicting roadmaps follow within a quarter.
The “extract first, reorg later” trap. Teams extract services while keeping the old functional org. The new service is touched by 6 teams, each making small changes, none deploying independently. This is the exact definition of a distributed monolith.
The “too many teams, too few services” trap. If you have 15 teams and 5 services, you will see queue-heavy feature delivery because every service release requires coordinating 3 teams. Service count and team count should grow roughly in parallel.
Solutions & Patterns — The Inverse Conway ManeuverInstead of fighting Conway’s Law, use it. Before you extract a service, verify there is a single team that can own it end-to-end: code, database, deploy pipeline, on-call rotation.Decision rule:No service should exist without a single owning team, and no team should own more than 2-3 services without platform support.Before/after example: At a healthtech company I advised, the “Appointments” service was owned by three teams — Scheduling, Notifications, and Billing — because the service touched all three concerns. Deploys required Slack coordination across team leads. After reorganizing so Scheduling team fully owned Appointments (with Billing and Notifications subscribing to its events via Kafka), deploy frequency for Appointments went from once every two weeks to daily, and incidents dropped by about 60%. The code barely changed; the org chart did.Practical implementation:
Start with the teams you want. Sketch the team topology (Stream-aligned teams, Platform team, Enabling team) from Team Topologies (Skelton and Pais, 2019).
Map services to teams before extraction. If two teams both claim a service, the service boundary is wrong.
Give each team deploy independence as the acceptance test. Can they deploy at 3 AM without waking anyone else? If not, the boundary is not real yet.
Projects You’ll Build
API Gateway
Build a custom API gateway with rate limiting, auth, and intelligent routing
Event Bus
Implement message broker integration with RabbitMQ and Apache Kafka
Saga Orchestrator
Build distributed transaction handling with compensation logic
Service Mesh Demo
Deploy services with Istio for traffic management, mTLS, and observability
Observability Stack
Set up Prometheus, Grafana, Jaeger, and centralized logging
Chaos Engineering Lab
Implement chaos experiments with LitmusChaos and game days
GraphQL Federation
Build unified APIs across microservices with Apollo Federation
E-Commerce Platform
Complete microservices application with 10+ production-ready services
Interview Topics Covered
System Design Questions
Design a URL shortener with microservices
Design an e-commerce checkout system
Design a notification service at scale
Design a real-time messaging system
Design a rate limiter service
Coding Questions
Implement circuit breaker from scratch
Design an event-driven order processing system
Build a distributed cache invalidation system
Implement saga pattern with compensation
Create a service discovery mechanism
Behavioral/Architecture Questions
When would you choose microservices over monolith?
How do you handle distributed transactions?
How do you debug issues in a microservices system?
How do you handle service failures gracefully?
How do you ensure data consistency across services?
Tech Stack
Category
Technologies
Languages
Node.js/TypeScript and Python 3.11+ (every example shown in both)
Every non-trivial code example in this course is shown in both Node.js/TypeScript and Python, side by side using tabbed blocks. You pick the stack you already use at work — the underlying distributed-systems patterns are identical in either language.
Why two languages? Most microservices interviewers care about the pattern (how do you implement a circuit breaker, idempotency key, saga step?), not your syntax. Showing both stacks makes it obvious which lines are the pattern and which lines are ceremony. If you can read the Node.js and the Python side of a circuit-breaker example, you understand the pattern deeply.
Node.js/TypeScript Stack
Layer
Library
Purpose
HTTP framework
Express, Fastify
REST APIs, middleware
HTTP client
axios, undici
Outbound calls with retries
ORM / data access
Prisma, TypeORM
Type-safe queries, migrations
Validation
zod, class-validator
Request/response schemas
Message broker
amqplib, kafkajs
RabbitMQ, Kafka producers/consumers
Resilience
opossum, cockatiel
Circuit breakers, retries, timeouts
Observability
@opentelemetry/api, pino
Tracing, structured logs
GraphQL
Apollo Server, @apollo/federation
Federated gateway + subgraphs
Testing
Jest, Vitest, Pact
Unit, integration, contract tests
Python Stack
Layer
Library
Purpose
HTTP framework
FastAPI
Async REST APIs with Pydantic validation
HTTP client
httpx
Async outbound calls with timeouts
ORM / data access
SQLAlchemy 2.0 (async)
Typed queries, Alembic migrations
Validation
Pydantic v2
Request/response schemas
Message broker
aiokafka, aio-pika
Kafka, RabbitMQ async clients
Resilience
pybreaker, tenacity
Circuit breakers, retry with backoff
Observability
opentelemetry-sdk, structlog
Tracing, structured logs
GraphQL
strawberry-graphql
Federation-compatible subgraphs
Testing
pytest, pytest-asyncio, schemathesis
Unit, integration, contract tests
Both stacks are production-grade and widely used at FAANG-tier companies. Node.js dominates Netflix, Uber’s gateway tier, and Stripe’s API edge. Python (especially FastAPI with SQLAlchemy 2.0) is everywhere at ML-heavy companies, fintech, and the data-engineering side of most large organizations.
Learning Path by Background
Not everyone should read this course linearly. Pick the path that matches how you plan to use it.
Backend Engineer Migrating to Microservices
You’ve built monoliths, you’re now on a team that’s decomposing one, and you need the full picture fast. Skip the philosophical “should we use microservices” debates — you’re already committed. Focus on the mechanics.Suggested reading order:
01 Foundations — Just the failure modes and trade-offs section, so you know what to watch for.
02 Domain-Driven Design — Bounded contexts are how you decide where to cut the monolith. This is non-negotiable.
24 Migration Patterns — Strangler fig, branch by abstraction, CDC. Read this before writing any new service.
03 Sync Communication + 04 Async Communication — You’ll use both. Understand when to reach for which.
06 Data Management + 19 Database Patterns — The hardest part of migration is the data. Budget weeks here.
07 Resilience Patterns + 09 Observability — Non-negotiable before production traffic hits the new service.
13 Testing — Contract tests are how you avoid 3am pages when your service schema drifts.
Estimated time: 6-8 weeks of focused study alongside day-job work.
SRE / Platform Engineer
You own the infrastructure, not the business logic. Your job is keeping 50 services running, not designing one. Skip the DDD chapter — you don’t decide bounded contexts. Go deep on the operational chapters.Suggested reading order:
11 Containerization + 12 Kubernetes — Your bread and butter. Read carefully.
09 Observability — Distributed tracing, metrics, log aggregation. This is your on-call lifeline.
08 Service Discovery + 23 Load Balancing — How requests actually find services in production.
16 Service Mesh — Istio, Linkerd. Decide whether you need it (usually only at 20+ services).
07 Resilience Patterns + 21 Chaos Engineering — You’ll be the one running game days.
You have a system-design round coming up in 4-8 weeks. You’re not building microservices at work, but the interviewer will ask about them. You need breadth, strong vocabulary, and 5-6 case studies you can cite confidently.Suggested reading order (interview-optimized):
14 Interview Prep — Read this first to calibrate what’s actually asked.
01 Foundations + 02 Domain-Driven Design — The “why” questions.
03 + 04 Communication — Sync vs async trade-offs, the most common follow-up.
06 Data Management — Sagas, CQRS, eventual consistency. Expect a drill-down here.
07 Resilience Patterns — Circuit breakers come up in almost every interview.
09 Observability — “How would you debug this?” is a senior-level screener.
22 Case Studies — Memorize 2-3 you can cite by name (Netflix Chaos Monkey, Uber Cadence, Amazon service ownership).
15 Capstone — Skim the architecture diagrams. You don’t need to build it.
Estimated time: 3-5 weeks if you’re studying evenings and weekends. Skip: 11, 12, 16, 17, 18, 21, 24, 25 unless the JD mentions them.
Engineering Manager
You won’t write the code, but you’ll own the decision: “should we adopt this pattern?” You need enough depth to push back on bad proposals, ask the right questions in design reviews, and budget correctly. Focus on trade-offs and case studies, skim the mechanics.Suggested reading order:
01 Foundations — Read the trade-offs and “hidden costs” sections carefully. Skim the code.
22 Case Studies — How Netflix, Uber, Amazon, Spotify structured their teams. This is Conway’s Law in practice.
24 Migration Patterns — If you’re leading a decomposition, this chapter is what you’ll reference for stakeholder conversations.
14 Interview Prep — Read the “What are the hidden costs?” answer. You’ll use this framing in budget discussions.
13 Testing + 18 CI/CD — Skim. Understand what contract testing buys you so you can advocate for it.
09 Observability — Skim the “infrastructure cost” commentary. Know the rough price tag.
21 Chaos Engineering — Just the philosophy section. Know what game days are and why they matter.
Estimated time: 2-3 weeks of reading. You’re optimizing for vocabulary and judgment, not implementation skill.
How to Use This Course
There’s no single right way to work through 27 chapters. Pick the strategy that matches your timeline and goals.
Strategy 1: Linear Deep Dive
Best for: Engineers with 16-20 weeks to invest who want mastery, not just interview readiness.Read chapters 00 through 26 in order. Do the code exercises in both Node.js and Python (pick your daily-driver language and do the other at a skim level). Build the capstone project in chapter 15 in parallel — it reinforces everything.Pace: 1-2 chapters per week. Expect 8-12 hours per chapter if you’re doing the exercises seriously.
Strategy 2: Topic-Focused
Best for: Engineers who already work with microservices but have specific gaps.Identify the 4-6 chapters that cover your weak spots (common gaps: sagas, circuit breakers, observability, Kubernetes internals). Read those deeply. Skim everything else. Use the “Key Takeaways” sidebars to self-assess.Pace: 4-6 weeks total. Focus on the gaps, don’t re-read what you already know.
Strategy 3: Interview Prep Only
Best for: Engineers with an interview in 3-5 weeks who need breadth and vocabulary.Follow the Full-Stack Engineer reading path above. Prioritize the “Strong Answer” boxes and “Vocabulary” sections. Memorize 2-3 real case studies you can cite. Practice explaining trade-offs out loud.Pace: 3-5 weeks. Skim code, memorize arguments. Don’t waste time on K8s manifests if your interview is about system design.
Strategy 4: Reference Guide
Best for: Senior engineers who already know this material but want a trusted lookup.Bookmark the chapters that match your current project. Use Ctrl+F for specific topics. Read the “Honest Truth” and “Pitfalls” sections of chapters you’re about to implement. The code blocks are production-quality and meant to be copied/adapted.Pace: Ongoing. Dip in when needed. The course is designed to hold up as a reference, not just a linear tutorial.
Whatever strategy you pick: do the “Self-Assessment” section of each chapter you read. If you can’t answer the “If you can debate X and Y, you’re at senior level” question, you haven’t finished the chapter — no matter how many lines you’ve read.
Ready to Begin?
Start with Foundations
Begin your microservices journey by understanding when and why to use microservices architecture.
Interview Deep-Dive
You are interviewing for a Senior Backend role. The interviewer says: 'We have a successful monolith serving 5 million users. Leadership wants to move to microservices. Walk me through how you would advise them.'
Strong Answer:The first thing I would push back on is the premise. “Leadership wants microservices” is not a technical requirement — it is an organizational desire. I would start by asking three questions: How many engineering teams are blocked on each other during deploys? Which components have fundamentally different scaling profiles? And what is their DevOps maturity — do they have CI/CD, container orchestration, and observability in place?If the answer is “two teams, uniform scaling, and we deploy manually,” microservices will make things worse, not better. At 5 million users with a single team, a well-structured modular monolith is almost certainly the right answer. You get module boundaries, clear interfaces, and the ability to extract later — without the operational tax of distributed systems.If they genuinely have 50+ engineers, clear domain boundaries, and mature DevOps, I would recommend an incremental approach using the Strangler Fig pattern. Start with the domain that has the most independent scaling needs or the highest deployment friction. Extract one service, run it in production for a quarter, learn what your infrastructure gaps are, and then decide whether to continue. The worst outcome is extracting 15 services in parallel and discovering your observability stack cannot handle distributed tracing across them.Follow-up: “What specific metrics would you track to know whether the migration is succeeding or failing?”I would track four things. First, deployment frequency per team — if microservices are working, teams should be deploying more often, not less. Second, change failure rate — are we breaking things more frequently because of distributed complexity? Third, mean time to recovery — when something breaks, can we isolate and fix it faster? Fourth, developer satisfaction scores, because if engineers hate the new system, adoption will stall regardless of the architecture’s elegance. Netflix tracks all four of these. If deployment frequency goes up but change failure rate also spikes, that tells you the team is moving fast without adequate testing or contract enforcement.
An interviewer asks: 'You mentioned that microservices are not always the right answer. Give me a concrete example of a company or team that adopted microservices too early and what went wrong.'
Strong Answer:The canonical example is Segment. They wrote a detailed blog post about moving from a monolith to microservices and then back to a monolith. They had around 100 engineers but their services became so fine-grained that a single customer event had to traverse 15+ services. The operational overhead was staggering: they spent more time debugging cross-service issues than building features. Their on-call rotations became nightmares because a single user-facing bug could involve 5 different service owners. They eventually consolidated back into a well-structured monolith and reported that engineering velocity increased significantly.The pattern I see repeatedly is: small teams adopt microservices because they read about Netflix doing it, without recognizing that Netflix has thousands of engineers and a dedicated platform team that builds internal tools for service management. When a 20-person startup has 30 services, each engineer is responsible for multiple services, and nobody understands the full system. You end up with a distributed monolith where every change requires coordinated deployments across services, which is strictly worse than the original monolith.The rule of thumb I use: if your team is small enough that everyone can fit in one room and understand the whole codebase, you do not need microservices. You need good module boundaries inside your monolith.Follow-up: “So when would you say the tipping point is — when does the pain of a monolith exceed the pain of microservices?”In my experience, the tipping point is not about lines of code or request volume — it is about team structure. When you have 3 or more teams that need to deploy independently on different cadences, and they are constantly blocking each other with merge conflicts and coordinated release windows, that is the signal. Conway’s Law is real: your architecture will mirror your organization. If you have autonomous teams with clear domain ownership, microservices support that autonomy. If you have one team wearing many hats, microservices just add overhead. The other signal is genuinely divergent scaling needs — if your search component needs 10x the compute of your user profile component, and you are paying for 10x compute across the entire monolith, that is a real financial argument for extraction.
'What are the hidden costs of microservices that most teams underestimate during planning?'
Strong Answer:There are five costs that consistently blindside teams:
Observability infrastructure. In a monolith, you grep a log file. In microservices, you need distributed tracing (Jaeger or Zipkin), centralized logging (ELK or Loki), metrics aggregation (Prometheus plus Grafana), and correlation IDs flowing through every service. At a previous company, setting up the observability stack for 12 services took a dedicated engineer three months and cost around $4,000/month in infrastructure.
Data consistency complexity. You lose ACID transactions across service boundaries. Suddenly every cross-service operation needs a saga pattern or event-driven choreography, with compensation logic for failures. A simple “place order, charge payment, reserve inventory” flow that was one database transaction becomes an asynchronous multi-step workflow with at least six failure modes.
Testing overhead. Contract testing, integration testing across services, and end-to-end testing all become exponentially harder. Teams that skip contract testing inevitably discover on a Friday afternoon that Service A changed its response format and Service B is now throwing null pointer exceptions in production.
Network reliability. Every inter-service call is a network call that can fail, time out, or return stale data. You need circuit breakers, retries with exponential backoff, fallback strategies, and timeout budgets. This is code that did not exist in the monolith and adds cognitive load to every feature.
Operational toil. Each service needs its own CI/CD pipeline, health checks, deployment configuration, secret management, and on-call rotation. Multiply every operational concern by the number of services. Teams with 20 services and no platform engineering team often spend 40-50% of their time on operational tasks rather than feature development.
Follow-up: “How would you budget for these costs when pitching a migration to leadership?”I would frame it as a tax rate. For the first year of migration, expect 30-40% of engineering capacity to go toward infrastructure and tooling rather than features. That decreases to maybe 15-20% once the platform stabilizes. I would also budget for a dedicated platform or infrastructure team — at minimum two engineers — once you pass 10 services. Without that investment, every product team reinvents the same wheels (logging, auth, deployment) differently, which compounds technical debt rapidly.
{"docsConfig":{"theme":"mint","$schema":"https://mintlify.com/docs.json","name":"Dev Weekends","colors":{"primary":"#000000","light":"#6B7280","dark":"#000000"},"favicon":"https://mintcdn.com/devweeekends/uFspW_ITEafc8XbV/images/logo.png?fit=max\u0026auto=format\u0026n=uFspW_ITEafc8XbV\u0026q=85\u0026s=24941b53d3f0793eb83974749e82df4f","navbar":{"links":[{"href":"https://devweekends.com","label":"Back to Site"}]},"footer":{"socials":{"youtube":"https://www.youtube.com/@devweekends","github":"https://github.com/DevWeekends","linkedin":"https://www.linkedin.com/company/dev-weekends"}},"contextual":{"options":["copy","view","chatgpt","claude","perplexity","mcp","cursor","vscode"],"display":"header"},"styling":{"latex":true},"navigation":{"global":{"anchors":[{"anchor":"DevWeekends","icon":"globe","href":"https://devweekends.com"}]},"pages":[]}},"deployment":{"deploymentMetadataValue":{"subdomain":"devweeekends","hasAudioNarration":false,"actualSubdomain":"devweeekends","customDomains":["resources.devweekends.com"],"gitSource":{"type":"github","owner":"devweekends","repo":"docs","deployBranch":"main","contentDirectory":"","isPrivate":false,"mountPath":"","label":""},"entitlements":{},"buildId":"6ad5cb977e3343e90aaa7f7f","clientVersion":"0.0.4205","searchFilterCounts":[{"language":"default","tag":"Courses","count":785},{"language":"default","tag":"Crash Courses","count":145},{"language":"default","tag":"Interview Prep","count":69},{"language":"default","tag":"AI Engineering","count":60},{"language":"default","tag":"Distributed System Tools","count":60},{"language":"default","tag":"Deep Learning Mastery","count":48},{"language":"default","tag":"DevOps Tools","count":38},{"language":"default","tag":"Think Like an Engineer","count":38},{"language":"default","tag":"Competitive Programming","count":37},{"language":"default","tag":"Angular Master Course","count":34}]},"assistantConfig":{"enableAskAiButton":false,"enableStarterQuestions":false,"enableAskAiSearchBar":true},"basePath":"","hasChatPermissions":false,"hasWebMcpPermissions":false,"toggles":[{"name":"kill-isr","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"custom-rbac-roles","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"agent-mintlify-slack","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"agent-integrations-settings","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"rbac-expansion","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"automations-pr-grouping","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"custom-prefix","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"analytics-v7","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"user-flows-analytics","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"no-publish-flow","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"workos-onboarding","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"snapshot-serving-live","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"stripTemperatureMiddleware","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"support-platform-pylon-zendesk","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"snapshot-serving","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"instant-rollback","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"granular-notifications-server","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"granular-notifications","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"automations-fable","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"fixed-ai-action-pricing","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"automation-resolve-merge-conflict","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"scoped-publishing","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"mintql","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"page-level-analytics","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"editor-version-history-v2","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"billing-page-v2","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"full-page-search","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"workspace-projects","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"assistant-v5","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"fork-pr-previews","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"revalidation-jwt","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"workos-sso-scim","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"hobby-abuse-scan","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"dashboard-inbox","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"workos-signup","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"turbopuffer-dual-write","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"workos-enabled","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"approve-review-flow","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"editor-metadata","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"sso-setup-deadline-banner","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"turbopuffer-serve","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"live-agents","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"starter-pricing","enabled":true,"variant":{"name":"treatment","enabled":true,"payload":{"type":"string","value":"treatment"},"feature_enabled":true},"impressionData":false},{"name":"llms-txt-v2","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false},{"name":"wildcard-email-auth","enabled":true,"variant":{"name":"disabled","enabled":false,"feature_enabled":true},"impressionData":false}],"googleFontsInlined":false},"customCss":[],"page":{"pagePath":"courses/microservices-mastery/00-overview","slug":"/courses/microservices-mastery/00-overview","pageMetadata":{"title":"Microservices Mastery","sidebarTitle":"Course Overview","description":"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews","icon":"cubes","href":"/courses/microservices-mastery/00-overview"},"description":{"compiledSource":"\"use strict\";\nconst {jsx: _jsx} = arguments[0];\nconst {useMDXComponents: _provideComponents} = arguments[0];\nfunction _createMdxContent(props) {\n const _components = {\n p: \"p\",\n ..._provideComponents(),\n ...props.components\n };\n return _jsx(_components.p, {\n children: \"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\"\n });\n}\nfunction MDXContent(props = {}) {\n const {wrapper: MDXLayout} = {\n ..._provideComponents(),\n ...props.components\n };\n return MDXLayout ? _jsx(MDXLayout, {\n ...props,\n children: _jsx(_createMdxContent, {\n ...props\n })\n }) : _createMdxContent(props);\n}\nreturn {\n default: MDXContent\n};\n","frontmatter":{},"scope":{}},"pageType":"default","mdx":{"mdxSource":{"compiledSource":"\"use strict\";const{Fragment:_Fragment,jsx:_jsx,jsxs:_jsxs}=arguments[0];const{useMDXComponents:_provideComponents}=arguments[0];function _createMdxContent(props){const _components={br:`br`,code:`code`,em:`em`,hr:`hr`,li:`li`,ol:`ol`,p:`p`,pre:`pre`,span:`span`,strong:`strong`,tbody:`tbody`,td:`td`,th:`th`,thead:`thead`,tr:`tr`,ul:`ul`,..._provideComponents(),...props.components},{Accordion,AccordionGroup,Card,CardGroup,CodeBlock,Heading,Info,Step,Steps,Table,Tip,Warning}=_components;if(!Accordion)_missingMdxReference(`Accordion`,true);if(!AccordionGroup)_missingMdxReference(`AccordionGroup`,true);if(!Card)_missingMdxReference(`Card`,true);if(!CardGroup)_missingMdxReference(`CardGroup`,true);if(!CodeBlock)_missingMdxReference(`CodeBlock`,true);if(!Heading)_missingMdxReference(`Heading`,true);if(!Info)_missingMdxReference(`Info`,true);if(!Step)_missingMdxReference(`Step`,true);if(!Steps)_missingMdxReference(`Steps`,true);if(!Table)_missingMdxReference(`Table`,true);if(!Tip)_missingMdxReference(`Tip`,true);if(!Warning)_missingMdxReference(`Warning`,true);return _jsxs(_Fragment,{children:[_jsx(Heading,{level:`1`,id:`microservices-mastery`,children:`Microservices Mastery`}),`\n`,_jsxs(_components.p,{children:[`A comprehensive, interview-focused curriculum designed for engineers targeting `,_jsx(_components.strong,{children:`Senior/Staff roles at top tech companies`}),` (Google, Amazon, Netflix, Uber, Stripe, etc.). This course covers everything from microservices fundamentals to production-ready distributed systems.`]}),`\n`,_jsx(Info,{children:_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Course Duration`}),`: 16-20 weeks (self-paced)`,_jsx(_components.br,{}),`\n`,_jsx(_components.strong,{children:`Target Outcome`}),`: Senior+ Engineer at FAANG / Top-tier microservices expertise`,_jsx(_components.br,{}),`\n`,_jsx(_components.strong,{children:`Prerequisites`}),`: Node.js or Python basics, REST APIs, basic database knowledge`,_jsx(_components.br,{}),`\n`,_jsx(_components.strong,{children:`Languages`}),`: Every code example is shown in `,_jsx(_components.strong,{children:`both Node.js/TypeScript and Python`}),` so you can learn in the stack you use at work`,_jsx(_components.br,{}),`\n`,_jsx(_components.strong,{children:`Projects`}),`: 10+ hands-on projects including a full e-commerce platform`,_jsx(_components.br,{}),`\n`,_jsx(_components.strong,{children:`Chapters`}),`: 27 in-depth chapters covering all aspects of microservices`]})}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`why-this-course`,children:`Why This Course?`}),`\n`,_jsxs(CardGroup,{cols:2,children:[_jsx(Card,{title:`Interview Ready`,icon:`building`,children:_jsx(_components.p,{children:`Covers exact topics asked at top tech companies for backend/distributed systems roles`})}),_jsx(Card,{title:`Production Patterns`,icon:`shield-halved`,children:_jsx(_components.p,{children:`Real patterns from systems handling millions of requests at Netflix, Uber, Amazon`})}),_jsx(Card,{title:`Hands-On Projects`,icon:`laptop-code`,children:_jsx(_components.p,{children:`Build a complete e-commerce platform with 10+ microservices`})}),_jsx(Card,{title:`Deep Technical Foundation`,icon:`book`,children:_jsx(_components.p,{children:`Understand the “why” behind every pattern, not just the “how”`})})]}),`\n`,_jsx(Warning,{children:_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Interview Reality`}),`: At Senior+ level, you’re expected to design microservices systems that handle `,_jsx(_components.strong,{children:`millions of requests`}),`, maintain `,_jsx(_components.strong,{children:`data consistency`}),`, and recover from `,_jsx(_components.strong,{children:`failures gracefully`}),`. This course prepares you for exactly that.`]})}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`before-you-begin-organizational-readiness`,children:`Before You Begin: Organizational Readiness`}),`\n`,_jsxs(_components.p,{children:[`Before you write a single `,_jsx(_components.code,{children:`docker-compose.yml`}),`, stop and check whether your organization is ready. The most expensive microservices mistakes are not technical — they are organizational. Teams adopt microservices because they read about Netflix or Amazon, not because their own context calls for it. The result is a distributed monolith with twice the operational cost and half the velocity of what they had before.`]}),`\n`,_jsxs(Warning,{children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Caveats \u0026 Common Pitfalls — Jumping to Microservices Without Org Readiness`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Teams adopt microservices before they can deploy reliably.`}),` If your current monolith takes 2 hours to deploy manually and rollback requires a Slack thread of 6 engineers, splitting into 12 services will make every deploy exponentially more painful. You need mature CI/CD, container orchestration, and observability `,_jsx(_components.em,{children:`before`}),` decomposition, not as a bonus goal.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Engineers mistake microservices for modularity.`}),` A well-structured modular monolith gives you 80% of the boundary benefits with 10% of the operational tax. If your pain is “code is tangled,” the answer is module boundaries and architectural tests, not a network hop.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Leadership pushes microservices for resume-driven reasons.`}),` “Our CTO wants microservices” is not a requirement; it is a preference. Convert it to measurable goals (deploy frequency, team independence, scaling granularity) and check whether monolith improvements could hit those goals first.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Conway’s Law is treated as a suggestion, not a law.`}),` If you have four functional teams (frontend, backend, database, QA), you will produce a four-tier architecture, regardless of the microservices diagram on the wall. The org chart wins every time.`]}),`\n`]})]}),`\n`,_jsxs(Tip,{children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Solutions \u0026 Patterns — The Org Readiness Checklist`})}),_jsxs(_components.p,{children:[`Before extracting your first service, verify these six prerequisites. This is the `,_jsx(_components.strong,{children:`“readiness checklist”`}),` that Martin Fowler and Sam Newman both cite as a minimum bar.`]}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Decision rule:`}),` If you cannot confidently check all six, your next investment should be in the gap — not in extracting services.`]}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Rapid provisioning`}),` — You can spin up a new environment (DB, runtime, load balancer) in under 30 minutes via automation.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Basic monitoring`}),` — You have structured logs, metrics, and at least one shared dashboard; you can answer “is service X healthy?” without SSH.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Rapid deployment`}),` — You can deploy a single service to production without a human approval chain longer than 15 minutes.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`DevOps culture`}),` — Developers own deployment, not a separate ops team who “releases” code.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Explicit domain boundaries`}),` — At least one Event Storming session has produced a context map that the whole team agrees on.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Team autonomy`}),` — Teams can make technical choices (framework, DB, language) without a central architecture review board blocking each decision.`]}),`\n`]}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Before/after example:`}),` A fintech team I worked with wanted to split their 400K-LOC Rails monolith into 20 services. They had manual deploys, one shared Postgres, and no distributed tracing. `,_jsx(_components.em,{children:`Before`}),` readiness work: 14 months of pain projected. `,_jsx(_components.em,{children:`After`}),` investing 4 months in CI/CD, tracing, and a modular-monolith refactor: they extracted the first service (fraud scoring) in 6 weeks with zero production incidents. The readiness work paid for itself before service #2.`]})]}),`\n`,_jsxs(AccordionGroup,{children:[_jsxs(Accordion,{title:`Interview: A VP of Engineering asks you 'Why shouldn't we just adopt microservices now so we're ready when we grow?' How do you respond?`,id:`interview-a-vp-of-engineering-asks-you-why-shouldnt-we-just-adopt-microservices-now-so-we-re-ready-when-we-grow-how-do-you-respond`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer Framework:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Reframe the question from “when” to “why.”`}),` Microservices are not an upgrade path — they are a different set of trade-offs. Ask what specific problems they are trying to solve.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Quantify the current pain.`}),` Deploy frequency, failed deploys, onboarding time, cross-team blockers. If these numbers are fine, the VP is optimizing for a future problem.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Calculate the distributed-systems tax.`}),` Roughly 30-40% of engineering capacity goes to infrastructure for the first year post-migration.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Propose the modular monolith as a bridge.`}),` You get boundary discipline, separate schemas, and architectural tests without the network hop. Extract later when the pain is real.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Agree on explicit triggers for extraction.`}),` “When deploy coordination costs exceed X hours/week per team” beats “when we’re bigger.”`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Real-World Example:`})}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Segment (2017-2018).`}),` Segment famously moved from a monolith to microservices, then back to a monolith. With about 100 engineers, their fine-grained services (150+ at peak) meant a single event crossed 15+ services, and debugging consumed more engineering time than feature work. They consolidated back, and their 2020 blog post became the canonical cautionary tale for premature decomposition.`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Senior Follow-up Questions:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“What metrics would prove to the VP that microservices are working?”`}),` Deploy frequency per team, change failure rate, mean time to recovery, and team-independence index (how often does team A block team B on a deploy?).`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“How would you handle a direct order to proceed anyway?”`}),` Propose a pilot: extract one service, run it for one quarter, and measure the metrics above. If they improve, continue. If not, pause.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“What’s the cheapest experiment that de-risks the decision?”`}),` Run a two-week modular-monolith spike: introduce strict module boundaries with architectural tests and see if the deploy coupling pain drops. If it does, you may not need microservices at all.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Common Wrong Answers:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“Sure, let’s start extracting services next sprint.”`}),` Fails because it skips the readiness audit and the org analysis. You will end up with a distributed monolith.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“Microservices are always better at scale; we should migrate.”`}),` Fails because it treats microservices as universally superior. Shopify, Basecamp, and Stack Overflow all run successful monoliths at scale.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Further Reading:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[`Martin Fowler, `,_jsx(_components.em,{children:`“Microservice Prerequisites”`}),` — the canonical readiness checklist.`]}),`\n`,_jsxs(_components.li,{children:[`Sam Newman, `,_jsx(_components.em,{children:`“Monolith to Microservices”`}),` (O’Reilly, 2019) — when and how to extract.`]}),`\n`,_jsxs(_components.li,{children:[`Segment’s `,_jsx(_components.em,{children:`“Goodbye Microservices”`}),` blog post (2018) — the pivot-back story in detail.`]}),`\n`]})]}),_jsxs(Accordion,{title:`Interview: 'When would you tell a team microservices would hurt more than help?' Give me your explicit decision criteria.`,id:`interview-when-would-you-tell-a-team-microservices-would-hurt-more-than-help-give-me-your-explicit-decision-criteria`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer Framework:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Team size under 15-20 engineers.`}),` Operational overhead per service is roughly constant; fixed costs swamp small teams.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Unclear or unstable domain boundaries.`}),` If you cannot name the contexts, extraction will freeze the wrong lines into APIs.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Strong consistency requirements across most workflows.`}),` If 70% of your flows need ACID across domains, distributed sagas will hurt every feature.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Limited DevOps maturity.`}),` No CI/CD, no observability, manual deploys — microservices will amplify these weaknesses.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`MVP or rapid-pivot stage.`}),` You need to change data models weekly; API contracts slow you down.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Uniform scaling profile.`}),` If every part of the system scales together, you gain nothing by scaling independently.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Real-World Example:`})}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Istio itself (2017-2019).`}),` Istio, the service mesh, initially shipped as a set of microservices (Pilot, Mixer, Citadel, Galley). By 2020 they consolidated back into a single binary called `,_jsx(_components.code,{children:`istiod`}),`. Reason: the microservices pattern added operational pain for users without buying internal development velocity, because a small team owned all four components.`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Senior Follow-up Questions:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“What about a 10-person team building a real-time trading platform?”`}),` Still probably a monolith, because latency budgets are tight and network hops are measurable. Extract only the pieces with truly different scaling profiles.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“You said ‘strong consistency across domains kills microservices’ — but Amazon uses microservices for orders and payments.”`}),` Amazon uses saga patterns with idempotent compensations, and they accept eventual consistency on non-critical paths. They invested a decade of platform engineering to make that cheap — it is not cheap for most teams.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“How do you spot ‘unclear domain boundaries’ early?”`}),` Run Event Storming. If the domain experts disagree on basic vocabulary (“is a customer the same as a user?”), freeze extraction until the business model clarifies.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Common Wrong Answers:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“Microservices are always right once you’re big enough.”`}),` Size is necessary but not sufficient. Basecamp (37signals) has stayed monolithic at scale by choice.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“You should extract when the codebase hits X lines of code.”`}),` LOC is a terrible metric. Coupling and team friction are the real signals.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Further Reading:`})}),_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`Google’s Istio v1 -> istiod consolidation blog (2020).`}),`\n`,_jsxs(_components.li,{children:[`DHH, `,_jsx(_components.em,{children:`“The Majestic Monolith”`}),` — Basecamp’s explicit anti-microservices position.`]}),`\n`,_jsxs(_components.li,{children:[`Matt Klein (Envoy creator), `,_jsx(_components.em,{children:`“Microservices: A Retrospective”`}),` on why service meshes should not themselves be mesh-of-services.`]}),`\n`]})]}),_jsxs(Accordion,{title:`Interview: Your team of 8 engineers has a 300K-LOC monolith and leadership wants to break it into 20 services in 6 months. What do you recommend?`,id:`interview-your-team-of-8-engineers-has-a-300k-loc-monolith-and-leadership-wants-to-break-it-into-20-services-in-6-months-what-do-you-recommend`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer Framework:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Push back on the timeline, not the goal.`}),` 20 services in 6 months with 8 engineers is a recipe for a distributed monolith. Propose extracting 1-2 services and reassessing.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Audit readiness first (2-4 weeks).`}),` CI/CD, observability, deployment automation. Fix gaps before extracting.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Identify the highest-pain boundary.`}),` Which module causes the most merge conflicts, has the most distinct scaling needs, or requires the most cross-team coordination? That is extraction #1.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Use the Strangler Fig pattern.`}),` Route new traffic to the new service behind the existing API gateway. Old code path remains until the new service is proven.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Define success metrics explicitly.`}),` Deploy frequency for the extracted service, number of cross-service incidents, team velocity changes.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Plan to stop.`}),` Commit to not extracting service #3 until #1 and #2 are fully stable.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Real-World Example:`})}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Shopify (2016-present).`}),` Despite serving millions of merchants, Shopify runs what they call the “majestic modular monolith” in Ruby. When they extract services, they do it surgically — for example, their Storefront Renderer was extracted specifically because its caching profile was dramatically different from admin. They did not set out to have “X services” — they set out to solve a specific scaling problem per extraction.`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Senior Follow-up Questions:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“What if leadership insists on all 20?”`}),` Present the risk in business terms: projected production incident rate, feature velocity drop, time-to-recovery projections. Offer a 3-month checkpoint with explicit kill criteria.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“How do you pick extraction #1?”`}),` Two factors: highest current pain (pick the module causing the most friction) and lowest coupling to the rest (pick something with a clean data boundary). You want an early win that builds confidence.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“What’s the sign you should stop extracting?”`}),` When cross-service debugging starts costing more engineering hours than the benefits of independence provide. Measure this explicitly.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Common Wrong Answers:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“Yes, we can do 20 services in 6 months if we hire contractors.”`}),` Staffing up mid-migration multiplies coordination cost. You will end with more services and less expertise per service.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.em,{children:`“Let’s do a big-bang rewrite.”`}),` Historically, rewrites from monolith to microservices-at-once have a failure rate above 70% (per DORA research). Incremental extraction is the only safe path.`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Further Reading:`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[`Shopify Engineering blog, `,_jsx(_components.em,{children:`“Deconstructing the Monolith”`}),` (2019).`]}),`\n`,_jsxs(_components.li,{children:[`Sam Newman, `,_jsx(_components.em,{children:`“Building Microservices”`}),` 2nd edition, Chapter 3 (Strangler Fig).`]}),`\n`,_jsxs(_components.li,{children:[`DORA `,_jsx(_components.em,{children:`Accelerate State of DevOps`}),` reports on rewrite failure rates.`]}),`\n`]})]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`what-companies-ask`,children:`What Companies Ask`}),`\n`,_jsxs(Table,{children:[_jsx(_components.thead,{children:_jsxs(_components.tr,{children:[_jsx(_components.th,{children:`Company`}),_jsx(_components.th,{children:`Common Microservices Topics`})]})}),_jsxs(_components.tbody,{children:[_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Amazon`})}),_jsx(_components.td,{children:`Service decomposition, eventual consistency, DynamoDB patterns, SQS/SNS`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Netflix`})}),_jsx(_components.td,{children:`Circuit breakers, chaos engineering, service mesh, Eureka`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Uber`})}),_jsx(_components.td,{children:`Event-driven architecture, Kafka, real-time systems, CQRS`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Stripe`})}),_jsx(_components.td,{children:`Distributed transactions, idempotency, exactly-once delivery`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Google`})}),_jsx(_components.td,{children:`gRPC, service discovery, load balancing, observability`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Meta`})}),_jsx(_components.td,{children:`Graph services, fan-out patterns, caching at scale`})]})]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`complete-curriculum`,children:`Complete Curriculum`}),`\n`,_jsxs(Table,{children:[_jsx(_components.thead,{children:_jsxs(_components.tr,{children:[_jsx(_components.th,{children:`#`}),_jsx(_components.th,{children:`Chapter`}),_jsx(_components.th,{children:`Topics`})]})}),_jsxs(_components.tbody,{children:[_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`00`}),_jsx(_components.td,{children:`Overview`}),_jsx(_components.td,{children:`Course structure, learning path, prerequisites`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`01`}),_jsx(_components.td,{children:`Foundations`}),_jsx(_components.td,{children:`Monolith vs microservices, when to use, trade-offs`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`02`}),_jsx(_components.td,{children:`Domain-Driven Design`}),_jsx(_components.td,{children:`Bounded contexts, aggregates, service decomposition`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`03`}),_jsx(_components.td,{children:`Sync Communication`}),_jsx(_components.td,{children:`REST, gRPC, protocol buffers, API versioning`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`04`}),_jsx(_components.td,{children:`Async Communication`}),_jsx(_components.td,{children:`Message queues, RabbitMQ, Kafka, event-driven`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`05`}),_jsx(_components.td,{children:`API Gateway`}),_jsx(_components.td,{children:`Routing, authentication, rate limiting, Kong`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`06`}),_jsx(_components.td,{children:`Data Management`}),_jsx(_components.td,{children:`Database per service, saga pattern, CQRS`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`07`}),_jsx(_components.td,{children:`Resilience Patterns`}),_jsx(_components.td,{children:`Circuit breaker, retry, bulkhead, timeout`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`08`}),_jsx(_components.td,{children:`Service Discovery`}),_jsx(_components.td,{children:`Consul, Eureka, DNS-based discovery`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`09`}),_jsx(_components.td,{children:`Observability`}),_jsx(_components.td,{children:`Tracing, logging, metrics, Prometheus, Jaeger`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`10`}),_jsx(_components.td,{children:`Security`}),_jsx(_components.td,{children:`OAuth2, JWT, mTLS, secrets management`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`11`}),_jsx(_components.td,{children:`Containerization`}),_jsx(_components.td,{children:`Docker, multi-stage builds, best practices`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`12`}),_jsx(_components.td,{children:`Kubernetes`}),_jsx(_components.td,{children:`Deployments, services, ConfigMaps, scaling`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`13`}),_jsx(_components.td,{children:`Testing`}),_jsx(_components.td,{children:`Unit, integration, contract, E2E testing`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`14`}),_jsx(_components.td,{children:`Interview Prep`}),_jsx(_components.td,{children:`Common questions, system design, coding`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`15`}),_jsx(_components.td,{children:`Capstone Project`}),_jsx(_components.td,{children:`E-commerce platform with 10+ services`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`16`}),_jsx(_components.td,{children:`Service Mesh`}),_jsx(_components.td,{children:`Istio, Linkerd, traffic management, mTLS`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`17`}),_jsx(_components.td,{children:`Configuration Management`}),_jsx(_components.td,{children:`Consul, feature flags, hot reload`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`18`}),_jsx(_components.td,{children:`CI/CD`}),_jsx(_components.td,{children:`GitOps, ArgoCD, GitHub Actions, canary deploys`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`19`}),_jsx(_components.td,{children:`Database Patterns`}),_jsx(_components.td,{children:`Data partitioning, migrations, replication`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`20`}),_jsx(_components.td,{children:`Caching Strategies`}),_jsx(_components.td,{children:`Redis, cache-aside, invalidation, distributed`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`21`}),_jsx(_components.td,{children:`Chaos Engineering`}),_jsx(_components.td,{children:`Chaos Monkey, LitmusChaos, game days`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`22`}),_jsx(_components.td,{children:`Case Studies`}),_jsx(_components.td,{children:`Netflix, Uber, Amazon, Spotify architectures`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`23`}),_jsx(_components.td,{children:`Load Balancing`}),_jsx(_components.td,{children:`Client/server-side, algorithms, health checks`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`24`}),_jsx(_components.td,{children:`Migration Patterns`}),_jsx(_components.td,{children:`Strangler fig, branch by abstraction, CDC`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`25`}),_jsx(_components.td,{children:`Event Sourcing Deep Dive`}),_jsx(_components.td,{children:`Event stores, projections, snapshots`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{\"data-numeric\":`true`,children:`26`}),_jsx(_components.td,{children:`GraphQL Federation`}),_jsx(_components.td,{children:`Apollo Federation, schema composition`})]})]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`course-structure`,children:`Course Structure`}),`\n`,_jsxs(_components.p,{children:[`The curriculum is organized into `,_jsx(_components.strong,{children:`10 tracks`}),` progressing from fundamentals to Staff+ expertise:`]}),`\n`,_jsx(CodeBlock,{numberOfLines:`53`,language:`text`,children:_jsx(_components.pre,{className:`shiki shiki-themes github-light-default dark-plus`,style:{backgroundColor:`#ffffff`,\"--shiki-dark-bg\":`#0B0C0E`,color:`#1f2328`,\"--shiki-dark\":`#D4D4D4`},language:`text`,children:_jsxs(_components.code,{language:`text`,numberOfLines:`53`,children:[_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`┌─────────────────────────────────────────────────────────────────────────────┐`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ MICROSERVICES MASTERY │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`├─────────────────────────────────────────────────────────────────────────────┤`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ TRACK 1: FOUNDATIONS TRACK 2: COMMUNICATION │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────── ──────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Monolith vs Microservices ☑ Synchronous (REST/gRPC) │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Domain-Driven Design ☑ Asynchronous (Message Queues) │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Service Decomposition ☑ Event-Driven Architecture │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ API Design Principles ☑ API Gateway Patterns │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Database per Service ☑ GraphQL Federation │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ TRACK 3: DATA MANAGEMENT TRACK 4: RESILIENCE │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────────── ────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Database per Service ☑ Circuit Breaker Pattern │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Saga Pattern ☑ Retry Strategies │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Event Sourcing ☑ Bulkhead Isolation │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ CQRS Pattern ☑ Timeout Patterns │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Caching Strategies ☑ Chaos Engineering │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ TRACK 5: DEPLOYMENT TRACK 6: OBSERVABILITY │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────── ──────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Containerization ☑ Distributed Tracing │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Kubernetes Basics ☑ Centralized Logging │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Service Discovery ☑ Metrics \u0026 Dashboards │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Service Mesh (Istio) ☑ Health Checks │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ CI/CD Pipelines ☑ Alerting Systems │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ TRACK 7: SECURITY TRACK 8: ADVANCED PATTERNS │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────── ──────────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Service-to-Service Auth ☑ Strangler Fig Pattern │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ API Gateway Security ☑ Backend for Frontend (BFF) │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Secrets Management ☑ Sidecar Pattern │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Zero Trust Architecture ☑ Ambassador Pattern │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Rate Limiting \u0026 Throttling ☑ Migration Patterns │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ TRACK 9: REAL-WORLD TRACK 10: INTERVIEW PREP │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────── ──────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Netflix Architecture ☑ System Design Questions │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Uber Dispatch System ☑ Coding Challenges │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Amazon SOA Journey ☑ Behavioral Questions │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Spotify Squad Model ☑ Architecture Deep Dives │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ☑ Configuration Management ☑ Capstone Project │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ═══════════════════════════════════════════════════════════════════════════│`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ CAPSTONE PROJECT: E-COMMERCE PLATFORM │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ ───────────────────────────────────── │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ □ User Service □ Order Service □ Inventory Service │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ □ Payment Service □ Notification Service □ Search Service │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ □ API Gateway □ Event Bus (Kafka) □ Full Observability │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`│ │`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{children:`└─────────────────────────────────────────────────────────────────────────────┘`})}),`\n`,_jsx(_components.span,{className:`line`,children:_jsx(_components.span,{})})]})})}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`learning-path`,children:`Learning Path`}),`\n`,_jsxs(Steps,{children:[_jsx(Step,{title:`Foundations (Week 1-2)`,children:_jsx(_components.p,{children:`Understand when and why to use microservices. Learn DDD and service decomposition strategies.`})}),_jsx(Step,{title:`Communication Patterns (Week 3-4)`,children:_jsx(_components.p,{children:`Master sync/async communication, event-driven architecture, and API gateway patterns.`})}),_jsx(Step,{title:`Data Management (Week 5-6)`,children:_jsx(_components.p,{children:`Handle distributed data with sagas, event sourcing, CQRS, and caching strategies.`})}),_jsx(Step,{title:`Resilience Patterns (Week 7-8)`,children:_jsx(_components.p,{children:`Build fault-tolerant services with circuit breakers, retries, bulkheads, and chaos engineering.`})}),_jsx(Step,{title:`Deployment \u0026 DevOps (Week 9-10)`,children:_jsx(_components.p,{children:`Deploy with Docker, Kubernetes, service mesh, and implement CI/CD pipelines.`})}),_jsx(Step,{title:`Observability (Week 11-12)`,children:_jsx(_components.p,{children:`Implement distributed tracing, logging, metrics, and comprehensive monitoring.`})}),_jsx(Step,{title:`Security \u0026 Advanced (Week 13-14)`,children:_jsx(_components.p,{children:`Secure your services and learn advanced architectural patterns including migration strategies.`})}),_jsx(Step,{title:`Case Studies (Week 15-16)`,children:_jsx(_components.p,{children:`Learn from Netflix, Uber, Amazon, and Spotify architectures. Understand real-world trade-offs.`})}),_jsx(Step,{title:`GraphQL \u0026 Event Sourcing (Week 17-18)`,children:_jsx(_components.p,{children:`Master GraphQL Federation and deep dive into event sourcing patterns.`})}),_jsx(Step,{title:`Capstone Project (Week 19-20)`,children:_jsx(_components.p,{children:`Build a production-ready e-commerce platform with 10+ services.`})})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`conway’s-law-as-a-warning-not-a-tattoo`,children:`Conway’s Law as a Warning, Not a Tattoo`}),`\n`,_jsx(_components.p,{children:`Every course on microservices mentions Conway’s Law. Most treat it as an inspirational quote. It is not. It is a load-bearing constraint on your architecture, and ignoring it is the fastest way to a distributed monolith.`}),`\n`,_jsxs(Warning,{children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Caveats \u0026 Common Pitfalls — The Conway Traps`})}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`The “diagram first, org last” trap.`}),` Architects draw a beautiful service mesh diagram, hand it to a functionally-organized engineering department, and expect the diagram to materialize. Six months later the “microservices” share databases and require cross-team tickets for every change. The org chart won.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`The shared-ownership trap.`}),` “This service is owned by the platform team `,_jsx(_components.em,{children:`and`}),` the payments team” means it is owned by nobody. On-call gaps, slow decisions, and conflicting roadmaps follow within a quarter.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`The “extract first, reorg later” trap.`}),` Teams extract services while keeping the old functional org. The new service is touched by 6 teams, each making small changes, none deploying independently. This is the exact definition of a distributed monolith.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`The “too many teams, too few services” trap.`}),` If you have 15 teams and 5 services, you will see queue-heavy feature delivery because every service release requires coordinating 3 teams. Service count and team count should grow roughly in parallel.`]}),`\n`]})]}),`\n`,_jsxs(Tip,{children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Solutions \u0026 Patterns — The Inverse Conway Maneuver`})}),_jsx(_components.p,{children:`Instead of fighting Conway’s Law, use it. Before you extract a service, verify there is a single team that can own it end-to-end: code, database, deploy pipeline, on-call rotation.`}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Decision rule:`}),` `,_jsx(_components.em,{children:`No service should exist without a single owning team, and no team should own more than 2-3 services without platform support.`})]}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Before/after example:`}),` At a healthtech company I advised, the “Appointments” service was owned by three teams — Scheduling, Notifications, and Billing — because the service touched all three concerns. Deploys required Slack coordination across team leads. `,_jsx(_components.em,{children:`After`}),` reorganizing so Scheduling team fully owned Appointments (with Billing and Notifications subscribing to its events via Kafka), deploy frequency for Appointments went from once every two weeks to daily, and incidents dropped by about 60%. The code barely changed; the org chart did.`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Practical implementation:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Start with the teams you want.`}),` Sketch the team topology (Stream-aligned teams, Platform team, Enabling team) from Team Topologies (Skelton and Pais, 2019).`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Map services to teams before extraction.`}),` If two teams both claim a service, the service boundary is wrong.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`Give each team deploy independence as the acceptance test.`}),` Can they deploy at 3 AM without waking anyone else? If not, the boundary is not real yet.`]}),`\n`]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`projects-you’ll-build`,children:`Projects You’ll Build`}),`\n`,_jsxs(CardGroup,{cols:2,children:[_jsx(Card,{title:`API Gateway`,icon:`door-open`,children:_jsx(_components.p,{children:`Build a custom API gateway with rate limiting, auth, and intelligent routing`})}),_jsx(Card,{title:`Event Bus`,icon:`envelope`,children:_jsx(_components.p,{children:`Implement message broker integration with RabbitMQ and Apache Kafka`})}),_jsx(Card,{title:`Saga Orchestrator`,icon:`sitemap`,children:_jsx(_components.p,{children:`Build distributed transaction handling with compensation logic`})}),_jsx(Card,{title:`Service Mesh Demo`,icon:`network-wired`,children:_jsx(_components.p,{children:`Deploy services with Istio for traffic management, mTLS, and observability`})}),_jsx(Card,{title:`Observability Stack`,icon:`chart-line`,children:_jsx(_components.p,{children:`Set up Prometheus, Grafana, Jaeger, and centralized logging`})}),_jsx(Card,{title:`Chaos Engineering Lab`,icon:`shuffle`,children:_jsx(_components.p,{children:`Implement chaos experiments with LitmusChaos and game days`})}),_jsx(Card,{title:`GraphQL Federation`,icon:`code-branch`,children:_jsx(_components.p,{children:`Build unified APIs across microservices with Apollo Federation`})}),_jsx(Card,{title:`E-Commerce Platform`,icon:`store`,children:_jsx(_components.p,{children:`Complete microservices application with 10+ production-ready services`})})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`interview-topics-covered`,children:`Interview Topics Covered`}),`\n`,_jsx(Heading,{level:`3`,id:`system-design-questions`,children:`System Design Questions`}),`\n`,_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`Design a URL shortener with microservices`}),`\n`,_jsx(_components.li,{children:`Design an e-commerce checkout system`}),`\n`,_jsx(_components.li,{children:`Design a notification service at scale`}),`\n`,_jsx(_components.li,{children:`Design a real-time messaging system`}),`\n`,_jsx(_components.li,{children:`Design a rate limiter service`}),`\n`]}),`\n`,_jsx(Heading,{level:`3`,id:`coding-questions`,children:`Coding Questions`}),`\n`,_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`Implement circuit breaker from scratch`}),`\n`,_jsx(_components.li,{children:`Design an event-driven order processing system`}),`\n`,_jsx(_components.li,{children:`Build a distributed cache invalidation system`}),`\n`,_jsx(_components.li,{children:`Implement saga pattern with compensation`}),`\n`,_jsx(_components.li,{children:`Create a service discovery mechanism`}),`\n`]}),`\n`,_jsx(Heading,{level:`3`,id:`behavioral/architecture-questions`,children:`Behavioral/Architecture Questions`}),`\n`,_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`When would you choose microservices over monolith?`}),`\n`,_jsx(_components.li,{children:`How do you handle distributed transactions?`}),`\n`,_jsx(_components.li,{children:`How do you debug issues in a microservices system?`}),`\n`,_jsx(_components.li,{children:`How do you handle service failures gracefully?`}),`\n`,_jsx(_components.li,{children:`How do you ensure data consistency across services?`}),`\n`]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`tech-stack`,children:`Tech Stack`}),`\n`,_jsxs(Table,{children:[_jsx(_components.thead,{children:_jsxs(_components.tr,{children:[_jsx(_components.th,{children:`Category`}),_jsx(_components.th,{children:`Technologies`})]})}),_jsxs(_components.tbody,{children:[_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Languages`})}),_jsxs(_components.td,{children:[`Node.js/TypeScript `,_jsx(_components.strong,{children:`and`}),` Python 3.11+ (every example shown in both)`]})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Frameworks`})}),_jsx(_components.td,{children:`Express, Fastify, NestJS (Node) / FastAPI (Python)`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Databases`})}),_jsx(_components.td,{children:`PostgreSQL, MongoDB, Redis`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Message Queues`})}),_jsx(_components.td,{children:`RabbitMQ, Apache Kafka`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Containers`})}),_jsx(_components.td,{children:`Docker, Docker Compose`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Orchestration`})}),_jsx(_components.td,{children:`Kubernetes, Helm`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`API Gateway`})}),_jsx(_components.td,{children:`Kong, Express Gateway`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Service Mesh`})}),_jsx(_components.td,{children:`Istio, Linkerd`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Observability`})}),_jsx(_components.td,{children:`Prometheus, Grafana, Jaeger, OpenTelemetry`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`CI/CD`})}),_jsx(_components.td,{children:`GitHub Actions, ArgoCD, GitOps`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`GraphQL`})}),_jsx(_components.td,{children:`Apollo Server, Apollo Federation`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Chaos Engineering`})}),_jsx(_components.td,{children:`Chaos Monkey, LitmusChaos`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Configuration`})}),_jsx(_components.td,{children:`Consul, ConfigMaps, Feature Flags`})]})]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`prerequisites`,children:`Prerequisites`}),`\n`,_jsxs(AccordionGroup,{children:[_jsx(Accordion,{title:`Node.js Fundamentals`,id:`node-js-fundamentals`,children:_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`JavaScript/TypeScript basics`}),`\n`,_jsx(_components.li,{children:`async/await, Promises`}),`\n`,_jsx(_components.li,{children:`Express.js basics`}),`\n`,_jsx(_components.li,{children:`npm/yarn package management`}),`\n`]})}),_jsx(Accordion,{title:`Database Knowledge`,id:`database-knowledge`,children:_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`SQL basics (PostgreSQL preferred)`}),`\n`,_jsx(_components.li,{children:`NoSQL concepts (MongoDB)`}),`\n`,_jsx(_components.li,{children:`Basic caching concepts`}),`\n`]})}),_jsx(Accordion,{title:`Web Development`,id:`web-development`,children:_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`REST API design`}),`\n`,_jsx(_components.li,{children:`HTTP methods and status codes`}),`\n`,_jsx(_components.li,{children:`JSON data format`}),`\n`,_jsx(_components.li,{children:`Basic authentication concepts`}),`\n`]})}),_jsx(Accordion,{title:`DevOps Basics`,id:`devops-basics`,children:_jsxs(_components.ul,{children:[`\n`,_jsx(_components.li,{children:`Command line basics`}),`\n`,_jsx(_components.li,{children:`Git version control`}),`\n`,_jsx(_components.li,{children:`Basic Docker knowledge (helpful but not required)`}),`\n`]})})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`languages-used-in-this-course`,children:`Languages Used in This Course`}),`\n`,_jsxs(_components.p,{children:[`Every non-trivial code example in this course is shown in `,_jsx(_components.strong,{children:`both Node.js/TypeScript and Python`}),`, side by side using tabbed blocks. You pick the stack you already use at work — the underlying distributed-systems patterns are identical in either language.`]}),`\n`,_jsx(Info,{children:_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Why two languages?`}),` Most microservices interviewers care about the `,_jsx(_components.em,{children:`pattern`}),` (how do you implement a circuit breaker, idempotency key, saga step?), not your syntax. Showing both stacks makes it obvious which lines are the pattern and which lines are ceremony. If you can read the Node.js and the Python side of a circuit-breaker example, you understand the pattern deeply.`]})}),`\n`,_jsx(Heading,{level:`3`,id:`node-js/typescript-stack`,children:`Node.js/TypeScript Stack`}),`\n`,_jsxs(Table,{children:[_jsx(_components.thead,{children:_jsxs(_components.tr,{children:[_jsx(_components.th,{children:`Layer`}),_jsx(_components.th,{children:`Library`}),_jsx(_components.th,{children:`Purpose`})]})}),_jsxs(_components.tbody,{children:[_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`HTTP framework`})}),_jsx(_components.td,{children:`Express, Fastify`}),_jsx(_components.td,{children:`REST APIs, middleware`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`HTTP client`})}),_jsx(_components.td,{children:`axios, undici`}),_jsx(_components.td,{children:`Outbound calls with retries`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`ORM / data access`})}),_jsx(_components.td,{children:`Prisma, TypeORM`}),_jsx(_components.td,{children:`Type-safe queries, migrations`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Validation`})}),_jsx(_components.td,{children:`zod, class-validator`}),_jsx(_components.td,{children:`Request/response schemas`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Message broker`})}),_jsx(_components.td,{children:`amqplib, kafkajs`}),_jsx(_components.td,{children:`RabbitMQ, Kafka producers/consumers`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Resilience`})}),_jsx(_components.td,{children:`opossum, cockatiel`}),_jsx(_components.td,{children:`Circuit breakers, retries, timeouts`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Observability`})}),_jsx(_components.td,{children:`@opentelemetry/api, pino`}),_jsx(_components.td,{children:`Tracing, structured logs`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`GraphQL`})}),_jsx(_components.td,{children:`Apollo Server, @apollo/federation`}),_jsx(_components.td,{children:`Federated gateway + subgraphs`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Testing`})}),_jsx(_components.td,{children:`Jest, Vitest, Pact`}),_jsx(_components.td,{children:`Unit, integration, contract tests`})]})]})]}),`\n`,_jsx(Heading,{level:`3`,id:`python-stack`,children:`Python Stack`}),`\n`,_jsxs(Table,{children:[_jsx(_components.thead,{children:_jsxs(_components.tr,{children:[_jsx(_components.th,{children:`Layer`}),_jsx(_components.th,{children:`Library`}),_jsx(_components.th,{children:`Purpose`})]})}),_jsxs(_components.tbody,{children:[_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`HTTP framework`})}),_jsx(_components.td,{children:`FastAPI`}),_jsx(_components.td,{children:`Async REST APIs with Pydantic validation`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`HTTP client`})}),_jsx(_components.td,{children:`httpx`}),_jsx(_components.td,{children:`Async outbound calls with timeouts`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`ORM / data access`})}),_jsx(_components.td,{children:`SQLAlchemy 2.0 (async)`}),_jsx(_components.td,{children:`Typed queries, Alembic migrations`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Validation`})}),_jsx(_components.td,{children:`Pydantic v2`}),_jsx(_components.td,{children:`Request/response schemas`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Message broker`})}),_jsx(_components.td,{children:`aiokafka, aio-pika`}),_jsx(_components.td,{children:`Kafka, RabbitMQ async clients`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Resilience`})}),_jsx(_components.td,{children:`pybreaker, tenacity`}),_jsx(_components.td,{children:`Circuit breakers, retry with backoff`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Observability`})}),_jsx(_components.td,{children:`opentelemetry-sdk, structlog`}),_jsx(_components.td,{children:`Tracing, structured logs`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`GraphQL`})}),_jsx(_components.td,{children:`strawberry-graphql`}),_jsx(_components.td,{children:`Federation-compatible subgraphs`})]}),_jsxs(_components.tr,{children:[_jsx(_components.td,{children:_jsx(_components.strong,{children:`Testing`})}),_jsx(_components.td,{children:`pytest, pytest-asyncio, schemathesis`}),_jsx(_components.td,{children:`Unit, integration, contract tests`})]})]})]}),`\n`,_jsx(_components.p,{children:`Both stacks are production-grade and widely used at FAANG-tier companies. Node.js dominates Netflix, Uber’s gateway tier, and Stripe’s API edge. Python (especially FastAPI with SQLAlchemy 2.0) is everywhere at ML-heavy companies, fintech, and the data-engineering side of most large organizations.`}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`learning-path-by-background`,children:`Learning Path by Background`}),`\n`,_jsx(_components.p,{children:`Not everyone should read this course linearly. Pick the path that matches how you plan to use it.`}),`\n`,_jsxs(AccordionGroup,{children:[_jsxs(Accordion,{title:`Backend Engineer Migrating to Microservices`,id:`backend-engineer-migrating-to-microservices`,children:[_jsx(_components.p,{children:`You’ve built monoliths, you’re now on a team that’s decomposing one, and you need the full picture fast. Skip the philosophical “should we use microservices” debates — you’re already committed. Focus on the mechanics.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Suggested reading order:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`01 Foundations`}),` — Just the failure modes and trade-offs section, so you know what to watch for.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`02 Domain-Driven Design`}),` — Bounded contexts are how you decide where to cut the monolith. This is non-negotiable.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`24 Migration Patterns`}),` — Strangler fig, branch by abstraction, CDC. Read this `,_jsx(_components.em,{children:`before`}),` writing any new service.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`03 Sync Communication + 04 Async Communication`}),` — You’ll use both. Understand when to reach for which.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`06 Data Management + 19 Database Patterns`}),` — The hardest part of migration is the data. Budget weeks here.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`07 Resilience Patterns + 09 Observability`}),` — Non-negotiable before production traffic hits the new service.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`13 Testing`}),` — Contract tests are how you avoid 3am pages when your service schema drifts.`]}),`\n`]}),_jsxs(_components.p,{children:[`Estimated time: `,_jsx(_components.strong,{children:`6-8 weeks`}),` of focused study alongside day-job work.`]})]}),_jsxs(Accordion,{title:`SRE / Platform Engineer`,id:`sre-platform-engineer`,children:[_jsx(_components.p,{children:`You own the infrastructure, not the business logic. Your job is keeping 50 services running, not designing one. Skip the DDD chapter — you don’t decide bounded contexts. Go deep on the operational chapters.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Suggested reading order:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`11 Containerization + 12 Kubernetes`}),` — Your bread and butter. Read carefully.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`09 Observability`}),` — Distributed tracing, metrics, log aggregation. This is your on-call lifeline.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`08 Service Discovery + 23 Load Balancing`}),` — How requests actually find services in production.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`16 Service Mesh`}),` — Istio, Linkerd. Decide whether you need it (usually only at 20+ services).`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`07 Resilience Patterns + 21 Chaos Engineering`}),` — You’ll be the one running game days.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`10 Security`}),` — mTLS, secrets rotation, zero-trust networking.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`17 Configuration Management + 18 CI/CD`}),` — Platform plumbing.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`22 Case Studies`}),` — How Netflix, Uber, Amazon structured their platform teams.`]}),`\n`]}),_jsxs(_components.p,{children:[`Estimated time: `,_jsx(_components.strong,{children:`5-7 weeks`}),`. Skip: 02, 14, 15, 25, 26 unless curious.`]})]}),_jsxs(Accordion,{title:`Full-Stack Engineer Preparing for Interviews`,id:`full-stack-engineer-preparing-for-interviews`,children:[_jsx(_components.p,{children:`You have a system-design round coming up in 4-8 weeks. You’re not building microservices at work, but the interviewer will ask about them. You need breadth, strong vocabulary, and 5-6 case studies you can cite confidently.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Suggested reading order (interview-optimized):`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`14 Interview Prep`}),` — Read this `,_jsx(_components.em,{children:`first`}),` to calibrate what’s actually asked.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`01 Foundations + 02 Domain-Driven Design`}),` — The “why” questions.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`03 + 04 Communication`}),` — Sync vs async trade-offs, the most common follow-up.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`06 Data Management`}),` — Sagas, CQRS, eventual consistency. Expect a drill-down here.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`07 Resilience Patterns`}),` — Circuit breakers come up in almost every interview.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`09 Observability`}),` — “How would you debug this?” is a senior-level screener.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`22 Case Studies`}),` — Memorize 2-3 you can cite by name (Netflix Chaos Monkey, Uber Cadence, Amazon service ownership).`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`15 Capstone`}),` — Skim the architecture diagrams. You don’t need to build it.`]}),`\n`]}),_jsxs(_components.p,{children:[`Estimated time: `,_jsx(_components.strong,{children:`3-5 weeks`}),` if you’re studying evenings and weekends. Skip: 11, 12, 16, 17, 18, 21, 24, 25 unless the JD mentions them.`]})]}),_jsxs(Accordion,{title:`Engineering Manager`,id:`engineering-manager`,children:[_jsx(_components.p,{children:`You won’t write the code, but you’ll own the decision: “should we adopt this pattern?” You need enough depth to push back on bad proposals, ask the right questions in design reviews, and budget correctly. Focus on trade-offs and case studies, skim the mechanics.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Suggested reading order:`})}),_jsxs(_components.ol,{children:[`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`01 Foundations`}),` — Read the trade-offs and “hidden costs” sections carefully. Skim the code.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`22 Case Studies`}),` — How Netflix, Uber, Amazon, Spotify structured their teams. This is Conway’s Law in practice.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`24 Migration Patterns`}),` — If you’re leading a decomposition, this chapter is what you’ll reference for stakeholder conversations.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`14 Interview Prep`}),` — Read the “What are the hidden costs?” answer. You’ll use this framing in budget discussions.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`13 Testing + 18 CI/CD`}),` — Skim. Understand what contract testing buys you so you can advocate for it.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`09 Observability`}),` — Skim the “infrastructure cost” commentary. Know the rough price tag.`]}),`\n`,_jsxs(_components.li,{children:[_jsx(_components.strong,{children:`21 Chaos Engineering`}),` — Just the philosophy section. Know what game days are and why they matter.`]}),`\n`]}),_jsxs(_components.p,{children:[`Estimated time: `,_jsx(_components.strong,{children:`2-3 weeks`}),` of reading. You’re optimizing for vocabulary and judgment, not implementation skill.`]})]})]}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`how-to-use-this-course`,children:`How to Use This Course`}),`\n`,_jsx(_components.p,{children:`There’s no single right way to work through 27 chapters. Pick the strategy that matches your timeline and goals.`}),`\n`,_jsxs(CardGroup,{cols:2,children:[_jsxs(Card,{title:`Strategy 1: Linear Deep Dive`,icon:`book-open`,children:[_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Best for:`}),` Engineers with 16-20 weeks to invest who want mastery, not just interview readiness.`]}),_jsx(_components.p,{children:`Read chapters 00 through 26 in order. Do the code exercises in both Node.js and Python (pick your daily-driver language and do the other at a skim level). Build the capstone project in chapter 15 in parallel — it reinforces everything.`}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Pace:`}),` 1-2 chapters per week. Expect 8-12 hours per chapter if you’re doing the exercises seriously.`]})]}),_jsxs(Card,{title:`Strategy 2: Topic-Focused`,icon:`bullseye`,children:[_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Best for:`}),` Engineers who already work with microservices but have specific gaps.`]}),_jsx(_components.p,{children:`Identify the 4-6 chapters that cover your weak spots (common gaps: sagas, circuit breakers, observability, Kubernetes internals). Read those deeply. Skim everything else. Use the “Key Takeaways” sidebars to self-assess.`}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Pace:`}),` 4-6 weeks total. Focus on the gaps, don’t re-read what you already know.`]})]}),_jsxs(Card,{title:`Strategy 3: Interview Prep Only`,icon:`user-tie`,children:[_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Best for:`}),` Engineers with an interview in 3-5 weeks who need breadth and vocabulary.`]}),_jsx(_components.p,{children:`Follow the Full-Stack Engineer reading path above. Prioritize the “Strong Answer” boxes and “Vocabulary” sections. Memorize 2-3 real case studies you can cite. Practice explaining trade-offs out loud.`}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Pace:`}),` 3-5 weeks. Skim code, memorize arguments. Don’t waste time on K8s manifests if your interview is about system design.`]})]}),_jsxs(Card,{title:`Strategy 4: Reference Guide`,icon:`book-bookmark`,children:[_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Best for:`}),` Senior engineers who already know this material but want a trusted lookup.`]}),_jsx(_components.p,{children:`Bookmark the chapters that match your current project. Use Ctrl+F for specific topics. Read the “Honest Truth” and “Pitfalls” sections of chapters you’re about to implement. The code blocks are production-quality and meant to be copied/adapted.`}),_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Pace:`}),` Ongoing. Dip in when needed. The course is designed to hold up as a reference, not just a linear tutorial.`]})]})]}),`\n`,_jsx(Tip,{children:_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Whatever strategy you pick:`}),` do the “Self-Assessment” section of each chapter you read. If you can’t answer the “If you can debate X and Y, you’re at senior level” question, you haven’t finished the chapter — no matter how many lines you’ve read.`]})}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`ready-to-begin`,children:`Ready to Begin?`}),`\n`,_jsx(Card,{title:`Start with Foundations`,icon:`play`,href:`/courses/microservices-mastery/01-foundations`,children:_jsx(_components.p,{children:`Begin your microservices journey by understanding when and why to use microservices architecture.`})}),`\n`,_jsx(_components.hr,{}),`\n`,_jsx(Heading,{level:`2`,id:`interview-deep-dive`,children:`Interview Deep-Dive`}),`\n`,_jsxs(AccordionGroup,{children:[_jsxs(Accordion,{title:`You are interviewing for a Senior Backend role. The interviewer says: 'We have a successful monolith serving 5 million users. Leadership wants to move to microservices. Walk me through how you would advise them.'`,id:`you-are-interviewing-for-a-senior-backend-role-the-interviewer-says-we-have-a-successful-monolith-serving-5-million-users-leadership-wants-to-move-to-microservices-walk-me-through-how-you-would-advise-them`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer:`})}),_jsx(_components.p,{children:`The first thing I would push back on is the premise. “Leadership wants microservices” is not a technical requirement — it is an organizational desire. I would start by asking three questions: How many engineering teams are blocked on each other during deploys? Which components have fundamentally different scaling profiles? And what is their DevOps maturity — do they have CI/CD, container orchestration, and observability in place?`}),_jsx(_components.p,{children:`If the answer is “two teams, uniform scaling, and we deploy manually,” microservices will make things worse, not better. At 5 million users with a single team, a well-structured modular monolith is almost certainly the right answer. You get module boundaries, clear interfaces, and the ability to extract later — without the operational tax of distributed systems.`}),_jsx(_components.p,{children:`If they genuinely have 50+ engineers, clear domain boundaries, and mature DevOps, I would recommend an incremental approach using the Strangler Fig pattern. Start with the domain that has the most independent scaling needs or the highest deployment friction. Extract one service, run it in production for a quarter, learn what your infrastructure gaps are, and then decide whether to continue. The worst outcome is extracting 15 services in parallel and discovering your observability stack cannot handle distributed tracing across them.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Follow-up: “What specific metrics would you track to know whether the migration is succeeding or failing?”`})}),_jsx(_components.p,{children:`I would track four things. First, deployment frequency per team — if microservices are working, teams should be deploying more often, not less. Second, change failure rate — are we breaking things more frequently because of distributed complexity? Third, mean time to recovery — when something breaks, can we isolate and fix it faster? Fourth, developer satisfaction scores, because if engineers hate the new system, adoption will stall regardless of the architecture’s elegance. Netflix tracks all four of these. If deployment frequency goes up but change failure rate also spikes, that tells you the team is moving fast without adequate testing or contract enforcement.`})]}),_jsxs(Accordion,{title:`An interviewer asks: 'You mentioned that microservices are not always the right answer. Give me a concrete example of a company or team that adopted microservices too early and what went wrong.'`,id:`an-interviewer-asks-you-mentioned-that-microservices-are-not-always-the-right-answer-give-me-a-concrete-example-of-a-company-or-team-that-adopted-microservices-too-early-and-what-went-wrong`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer:`})}),_jsx(_components.p,{children:`The canonical example is Segment. They wrote a detailed blog post about moving from a monolith to microservices and then back to a monolith. They had around 100 engineers but their services became so fine-grained that a single customer event had to traverse 15+ services. The operational overhead was staggering: they spent more time debugging cross-service issues than building features. Their on-call rotations became nightmares because a single user-facing bug could involve 5 different service owners. They eventually consolidated back into a well-structured monolith and reported that engineering velocity increased significantly.`}),_jsx(_components.p,{children:`The pattern I see repeatedly is: small teams adopt microservices because they read about Netflix doing it, without recognizing that Netflix has thousands of engineers and a dedicated platform team that builds internal tools for service management. When a 20-person startup has 30 services, each engineer is responsible for multiple services, and nobody understands the full system. You end up with a distributed monolith where every change requires coordinated deployments across services, which is strictly worse than the original monolith.`}),_jsx(_components.p,{children:`The rule of thumb I use: if your team is small enough that everyone can fit in one room and understand the whole codebase, you do not need microservices. You need good module boundaries inside your monolith.`}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Follow-up: “So when would you say the tipping point is — when does the pain of a monolith exceed the pain of microservices?”`})}),_jsx(_components.p,{children:`In my experience, the tipping point is not about lines of code or request volume — it is about team structure. When you have 3 or more teams that need to deploy independently on different cadences, and they are constantly blocking each other with merge conflicts and coordinated release windows, that is the signal. Conway’s Law is real: your architecture will mirror your organization. If you have autonomous teams with clear domain ownership, microservices support that autonomy. If you have one team wearing many hats, microservices just add overhead. The other signal is genuinely divergent scaling needs — if your search component needs 10x the compute of your user profile component, and you are paying for 10x compute across the entire monolith, that is a real financial argument for extraction.`})]}),_jsxs(Accordion,{title:`'What are the hidden costs of microservices that most teams underestimate during planning?'`,id:`what-are-the-hidden-costs-of-microservices-that-most-teams-underestimate-during-planning`,children:[_jsx(_components.p,{children:_jsx(_components.strong,{children:`Strong Answer:`})}),_jsx(_components.p,{children:`There are five costs that consistently blindside teams:`}),_jsxs(_components.ul,{children:[`\n`,_jsxs(_components.li,{children:[`\n`,_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Observability infrastructure.`}),` In a monolith, you grep a log file. In microservices, you need distributed tracing (Jaeger or Zipkin), centralized logging (ELK or Loki), metrics aggregation (Prometheus plus Grafana), and correlation IDs flowing through every service. At a previous company, setting up the observability stack for 12 services took a dedicated engineer three months and cost around $4,000/month in infrastructure.`]}),`\n`]}),`\n`,_jsxs(_components.li,{children:[`\n`,_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Data consistency complexity.`}),` You lose ACID transactions across service boundaries. Suddenly every cross-service operation needs a saga pattern or event-driven choreography, with compensation logic for failures. A simple “place order, charge payment, reserve inventory” flow that was one database transaction becomes an asynchronous multi-step workflow with at least six failure modes.`]}),`\n`]}),`\n`,_jsxs(_components.li,{children:[`\n`,_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Testing overhead.`}),` Contract testing, integration testing across services, and end-to-end testing all become exponentially harder. Teams that skip contract testing inevitably discover on a Friday afternoon that Service A changed its response format and Service B is now throwing null pointer exceptions in production.`]}),`\n`]}),`\n`,_jsxs(_components.li,{children:[`\n`,_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Network reliability.`}),` Every inter-service call is a network call that can fail, time out, or return stale data. You need circuit breakers, retries with exponential backoff, fallback strategies, and timeout budgets. This is code that did not exist in the monolith and adds cognitive load to every feature.`]}),`\n`]}),`\n`,_jsxs(_components.li,{children:[`\n`,_jsxs(_components.p,{children:[_jsx(_components.strong,{children:`Operational toil.`}),` Each service needs its own CI/CD pipeline, health checks, deployment configuration, secret management, and on-call rotation. Multiply every operational concern by the number of services. Teams with 20 services and no platform engineering team often spend 40-50% of their time on operational tasks rather than feature development.`]}),`\n`]}),`\n`]}),_jsx(_components.p,{children:_jsx(_components.strong,{children:`Follow-up: “How would you budget for these costs when pitching a migration to leadership?”`})}),_jsx(_components.p,{children:`I would frame it as a tax rate. For the first year of migration, expect 30-40% of engineering capacity to go toward infrastructure and tooling rather than features. That decreases to maybe 15-20% once the platform stabilizes. I would also budget for a dedicated platform or infrastructure team — at minimum two engineers — once you pass 10 services. Without that investment, every product team reinvents the same wheels (logging, auth, deployment) differently, which compounds technical debt rapidly.`})]})]})]})}function MDXContent(props={}){const{wrapper:MDXLayout}={..._provideComponents(),...props.components};return MDXLayout?_jsx(MDXLayout,{...props,children:_jsx(_createMdxContent,{...props})}):_createMdxContent(props)}return{default:MDXContent};function _missingMdxReference(id,component){throw new Error(`Expected `+(component?`component`:`object`)+\" `\"+id+\"` to be defined: you likely forgot to import, pass, or provide it.\")}","frontmatter":{},"scope":{"config":{},"pageMetadata":{"title":"Microservices Mastery","sidebarTitle":"Course Overview","description":"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews","icon":"cubes","href":"/courses/microservices-mastery/00-overview"}}},"mdxSourceWithNoJs":null},"mdxExtracts":{"tableOfContents":[{"title":"Microservices Mastery","slug":"microservices-mastery","depth":1,"children":[]},{"title":"Why This Course?","slug":"why-this-course","depth":2,"children":[]},{"title":"Before You Begin: Organizational Readiness","slug":"before-you-begin-organizational-readiness","depth":2,"children":[]},{"title":"What Companies Ask","slug":"what-companies-ask","depth":2,"children":[]},{"title":"Complete Curriculum","slug":"complete-curriculum","depth":2,"children":[]},{"title":"Course Structure","slug":"course-structure","depth":2,"children":[]},{"title":"Learning Path","slug":"learning-path","depth":2,"children":[]},{"title":"Conway’s Law as a Warning, Not a Tattoo","slug":"conway’s-law-as-a-warning-not-a-tattoo","depth":2,"children":[]},{"title":"Projects You’ll Build","slug":"projects-you’ll-build","depth":2,"children":[]},{"title":"Interview Topics Covered","slug":"interview-topics-covered","depth":2,"children":[{"title":"System Design Questions","slug":"system-design-questions","depth":3,"children":[]},{"title":"Coding Questions","slug":"coding-questions","depth":3,"children":[]},{"title":"Behavioral/Architecture Questions","slug":"behavioral/architecture-questions","depth":3,"children":[]}]},{"title":"Tech Stack","slug":"tech-stack","depth":2,"children":[]},{"title":"Prerequisites","slug":"prerequisites","depth":2,"children":[]},{"title":"Languages Used in This Course","slug":"languages-used-in-this-course","depth":2,"children":[{"title":"Node.js/TypeScript Stack","slug":"node-js/typescript-stack","depth":3,"children":[]},{"title":"Python Stack","slug":"python-stack","depth":3,"children":[]}]},{"title":"Learning Path by Background","slug":"learning-path-by-background","depth":2,"children":[]},{"title":"How to Use This Course","slug":"how-to-use-this-course","depth":2,"children":[]},{"title":"Ready to Begin?","slug":"ready-to-begin","depth":2,"children":[]},{"title":"Interview Deep-Dive","slug":"interview-deep-dive","depth":2,"children":[]}],"codeExamples":{}},"jsLinks":[],"subdomain":"devweeekends","siteName":"Dev Weekends","title":"Microservices Mastery - Dev Weekends","navMaps":{"firstHrefInVersion":{},"firstHrefInLanguage":{}},"lastModified":"2026-05-16T10:36:03.332Z","originalFileLocation":"courses/microservices-mastery/00-overview.mdx"},"headHtml":"\u003cscript data-mint-head>(function(){var d=document.documentElement,p=null;if(!p){try{p=localStorage.getItem(\"isDarkMode\")}catch(e){}if(p==='true')p='dark';else if(p==='false')p='light';if(p!=='light'\u0026\u0026p!=='dark'\u0026\u0026p!=='system')p=\"system\"}var r=p==='system'?(matchMedia(\"(prefers-color-scheme: dark)\").matches?'dark':'light'):p;d.classList.remove(r==='dark'?'light':'dark');d.classList.add(r);d.setAttribute(\"data-theme-preference\",p)})();\u003c/script>\u003cmeta data-mint-head name=\"description\" content=\"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\">\u003cmeta data-mint-head name=\"application-name\" content=\"Dev Weekends\">\u003cmeta data-mint-head name=\"generator\" content=\"Mintlify\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"192x192\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/android-chrome-192x192.png\" media=\"(prefers-color-scheme: light)\">\u003clink data-mint-head rel=\"apple-touch-icon\" type=\"image/png\" sizes=\"180x180\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/apple-touch-icon.png\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"16x16\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/favicon-16x16.png\" media=\"(prefers-color-scheme: light)\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"32x32\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/favicon-32x32.png\" media=\"(prefers-color-scheme: light)\">\u003clink data-mint-head rel=\"shortcut icon\" type=\"image/x-icon\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/favicon.ico\" media=\"(prefers-color-scheme: light)\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"192x192\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon-dark/android-chrome-192x192.png\" media=\"(prefers-color-scheme: dark)\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"16x16\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon-dark/favicon-16x16.png\" media=\"(prefers-color-scheme: dark)\">\u003clink data-mint-head rel=\"icon\" type=\"image/png\" sizes=\"32x32\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon-dark/favicon-32x32.png\" media=\"(prefers-color-scheme: dark)\">\u003clink data-mint-head rel=\"shortcut icon\" type=\"image/x-icon\" href=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon-dark/favicon.ico\" media=\"(prefers-color-scheme: dark)\">\u003cmeta data-mint-head property=\"og:title\" content=\"Microservices Mastery - Dev Weekends\">\u003cmeta data-mint-head property=\"og:description\" content=\"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\">\u003cmeta data-mint-head property=\"og:site_name\" content=\"Dev Weekends\">\u003cmeta data-mint-head property=\"og:url\" content=\"https://resources.devweekends.com/courses/microservices-mastery/00-overview\">\u003cmeta data-mint-head property=\"og:type\" content=\"website\">\u003cmeta data-mint-head property=\"og:image\" content=\"https://devweeekends.mintlify.site/_mintlify/api/og/v2?division=Microservices+Mastery\u0026amp;title=Microservices+Mastery\u0026amp;description=Master+microservices+architecture+with+Node.js+and+Python+%E2%80%94+From+fundamentals+to+production-ready+systems+for+top+tech+company+interviews\u0026amp;theme=97ffacf68ee2a7d59a7fcf65\u0026amp;signature=59eaa31e5d7841d3a49b533df969b9b543bb8ec88388b35223bc74936332011d\">\u003cmeta data-mint-head property=\"og:image:width\" content=\"1200\">\u003cmeta data-mint-head property=\"og:image:height\" content=\"630\">\u003cmeta data-mint-head name=\"twitter:card\" content=\"summary_large_image\">\u003cmeta data-mint-head name=\"twitter:title\" content=\"Microservices Mastery - Dev Weekends\">\u003cmeta data-mint-head name=\"twitter:description\" content=\"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\">\u003cmeta data-mint-head name=\"twitter:image\" content=\"https://devweeekends.mintlify.site/_mintlify/api/og/v2?division=Microservices+Mastery\u0026amp;title=Microservices+Mastery\u0026amp;description=Master+microservices+architecture+with+Node.js+and+Python+%E2%80%94+From+fundamentals+to+production-ready+systems+for+top+tech+company+interviews\u0026amp;theme=97ffacf68ee2a7d59a7fcf65\u0026amp;signature=59eaa31e5d7841d3a49b533df969b9b543bb8ec88388b35223bc74936332011d\">\u003cmeta data-mint-head name=\"twitter:image:width\" content=\"1200\">\u003cmeta data-mint-head name=\"twitter:image:height\" content=\"630\">\u003cmeta data-mint-head name=\"msapplication-config\" content=\"/mintlify-assets/_mintlify/favicons/devweeekends/VN0XII-rWbxEMed4/_generated/favicon/browserconfig.xml\">\u003cmeta data-mint-head name=\"apple-mobile-web-app-title\" content=\"Dev Weekends\">\u003cmeta data-mint-head name=\"msapplication-TileColor\" content=\"#000000\">\u003clink data-mint-head rel=\"canonical\" href=\"https://resources.devweekends.com/courses/microservices-mastery/00-overview\">\u003clink data-mint-head rel=\"alternate\" type=\"application/xml\" href=\"/sitemap.xml\">\u003clink data-mint-head rel=\"alternate\" type=\"text/markdown\" href=\"/courses/microservices-mastery/00-overview.md\">\u003cscript data-mint-head type=\"application/ld+json\">{\"@context\":\"https://schema.org\",\"@graph\":[{\"@type\":\"Organization\",\"@id\":\"https://resources.devweekends.com/#organization\",\"name\":\"Dev Weekends\",\"url\":\"https://resources.devweekends.com\"},{\"@type\":\"WebSite\",\"@id\":\"https://resources.devweekends.com#website\",\"name\":\"Dev Weekends\",\"url\":\"https://resources.devweekends.com\",\"publisher\":{\"@id\":\"https://resources.devweekends.com/#organization\"}},{\"@type\":\"WebPage\",\"@id\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview#webpage\",\"url\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview\",\"name\":\"Microservices Mastery\",\"description\":\"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\",\"dateModified\":\"2026-05-16T10:36:03.332Z\",\"isPartOf\":{\"@id\":\"https://resources.devweekends.com#website\"},\"breadcrumb\":{\"@id\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview#breadcrumb\"}},{\"@type\":\"BreadcrumbList\",\"@id\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Dev Weekends\",\"item\":\"https://resources.devweekends.com\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Microservices Mastery\",\"item\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview\"}]},{\"@type\":[\"Article\",\"TechArticle\"],\"@id\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview#article\",\"headline\":\"Microservices Mastery\",\"name\":\"Microservices Mastery\",\"description\":\"Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews\",\"url\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview\",\"mainEntityOfPage\":{\"@id\":\"https://resources.devweekends.com/courses/microservices-mastery/00-overview#webpage\"},\"dateModified\":\"2026-05-16T10:36:03.332Z\",\"publisher\":{\"@id\":\"https://resources.devweekends.com/#organization\"},\"isPartOf\":{\"@id\":\"https://resources.devweekends.com#website\"}}]}\u003c/script>\u003cscript data-mint-head type=\"application/ld+json\">{\"@context\":\"https://schema.org\",\"@type\":\"WebSite\",\"name\":\"Dev Weekends\",\"publisher\":{\"@type\":\"Organization\",\"name\":\"Dev Weekends\"},\"provider\":{\"@type\":\"Organization\",\"name\":\"Mintlify\",\"url\":\"https://mintlify.com\"}}\u003c/script>","agentPointerHref":"/courses/microservices-mastery/00-overview.md","siteName":"Dev Weekends","nav":{"global":{"anchors":[{"anchor":"DevWeekends","icon":"globe","href":"https://devweekends.com"}]},"anchors":[{"anchor":"Resources","icon":"book-open","pages":[{"title":"Resources","href":""}]},{"anchor":"Interview Prep","icon":"clipboard-check","pages":[{"title":"Interview Prep","href":"/resources/interview-experiences"}]},{"anchor":"DSA Patterns","icon":"code","pages":[{"title":"DSA Patterns","href":"/dsa-patterns/overview"}]},{"anchor":"Competitive Programming","icon":"trophy","pages":[{"title":"Competitive Programming","href":"/courses/competitive-programming/00-overview"}]},{"anchor":"Courses","icon":"graduation-cap","groups":[{"group":"Overview","pages":[{"title":"All Courses","icon":"graduation-cap","href":"/courses/overview"}]},{"group":"Testing \u0026 Code Quality","icon":"vial","pages":[{"title":"Sonarqube Mastery","sidebarTitle":"Sonarqube","icon":"magnifying-glass-chart","href":"/courses/testing-tools/sonarqube"},{"title":"Playwright Mastery","sidebarTitle":"Playwright","icon":"masks-theater","href":"/courses/testing-tools/playwright"},{"title":"Mocha Mastery","sidebarTitle":"Mocha","icon":"coffee-bean","href":"/courses/testing-tools/mocha"},{"title":"Jest Mastery","sidebarTitle":"Jest","icon":"jester-hat","href":"/courses/testing-tools/jest"}]},{"group":"Crash Courses","icon":"bolt","pages":[{"group":"C++","icon":"brackets-curly","pages":[{"title":"C++ Crash Course","sidebarTitle":"Overview","icon":"code","href":"/courses/cpp-crash-course/overview"},{"title":"C++ Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/cpp-crash-course/fundamentals"},{"title":"Pointers \u0026 Memory","sidebarTitle":"2. Memory Mastery","icon":"memory","href":"/courses/cpp-crash-course/pointers-memory"},{"title":"Object-Oriented Programming","sidebarTitle":"3. OOP","icon":"object-group","href":"/courses/cpp-crash-course/oop"},{"title":"Standard Template Library","sidebarTitle":"4. The STL","icon":"layer-group","href":"/courses/cpp-crash-course/stl"},{"title":"Modern C++ Features","sidebarTitle":"5. Modern C++","icon":"wand-magic-sparkles","href":"/courses/cpp-crash-course/modern-cpp"}]},{"group":"Java","icon":"mug-hot","pages":[{"title":"Java Crash Course","sidebarTitle":"Overview","icon":"mug-hot","href":"/courses/java-crash-course/overview"},{"title":"Java Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/java-crash-course/fundamentals"},{"title":"Object-Oriented Programming","sidebarTitle":"2. OOP","icon":"object-group","href":"/courses/java-crash-course/oop"},{"title":"Collections Framework","sidebarTitle":"3. Collections","icon":"layer-group","href":"/courses/java-crash-course/collections"},{"title":"Concurrency","sidebarTitle":"4. Concurrency","icon":"bolt","href":"/courses/java-crash-course/concurrency"},{"title":"Modern Java Features","sidebarTitle":"5. Modern Java","icon":"wand-magic-sparkles","href":"/courses/java-crash-course/modern-java"}]},{"group":"Spring Boot \u0026 Microservices","icon":"leaf","pages":[{"title":"Spring Boot \u0026 Microservices","sidebarTitle":"Overview","icon":"leaf","href":"/courses/spring-boot-microservices/00-overview"},{"title":"Spring Boot Quickstart","icon":"bolt","href":"/courses/spring-boot-microservices/01-spring-boot-quickstart"},{"title":"Spring MVC \u0026 REST","icon":"server","href":"/courses/spring-boot-microservices/02-spring-mvc-rest"},{"title":"Data Persistence","icon":"database","href":"/courses/spring-boot-microservices/03-data-persistence"},{"title":"Deep Dive: Spring AOP","icon":"microscope","href":"/courses/spring-boot-microservices/04-spring-aop"},{"title":"Testing Mastery","icon":"vial","href":"/courses/spring-boot-microservices/05-spring-testing"},{"title":"Foundations","icon":"shapes","href":"/courses/spring-boot-microservices/06-microservices-foundations"},{"title":"Service Discovery","icon":"compass","href":"/courses/spring-boot-microservices/07-service-discovery"},{"title":"API Gateway","icon":"door-open","href":"/courses/spring-boot-microservices/08-api-gateway"},{"title":"Config Management","icon":"gears","href":"/courses/spring-boot-microservices/09-config-management"},{"title":"Resilience \u0026 Fault Tolerance","icon":"shield-halved","href":"/courses/spring-boot-microservices/10-resilience"},{"title":"Observability","icon":"monitor-waveform","href":"/courses/spring-boot-microservices/11-observability"},{"title":"Event Driven Architecture","icon":"satellite-dish","href":"/courses/spring-boot-microservices/12-event-driven"},{"title":"Containerization","icon":"docker","href":"/courses/spring-boot-microservices/13-containerization"},{"title":"Capstone Project","icon":"flag-checkered","href":"/courses/spring-boot-microservices/14-capstone"}]},{"group":"JavaScript","icon":"js","pages":[{"title":"JavaScript Crash Course","sidebarTitle":"Overview","icon":"js","href":"/courses/javascript-crash-course/overview"},{"title":"JavaScript Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/javascript-crash-course/fundamentals"},{"title":"Functions \u0026 Scope","sidebarTitle":"2. Functions \u0026 Scope","icon":"function","href":"/courses/javascript-crash-course/functions-scope"},{"title":"Objects \u0026 Prototypes","sidebarTitle":"3. Objects \u0026 Prototypes","icon":"object-group","href":"/courses/javascript-crash-course/objects-prototypes"},{"title":"Async JavaScript","sidebarTitle":"4. Async JavaScript","icon":"clock","href":"/courses/javascript-crash-course/async"},{"title":"Modern JavaScript (ES6+)","sidebarTitle":"5. Modern JavaScript","icon":"wand-magic-sparkles","href":"/courses/javascript-crash-course/modern-js"},{"title":"DOM \u0026 Browser APIs","sidebarTitle":"6. DOM \u0026 Browser","icon":"browser","href":"/courses/javascript-crash-course/dom-browser"}]},{"group":"TypeScript","icon":"file-code","pages":[{"title":"TypeScript Crash Course","sidebarTitle":"Overview","icon":"code","href":"/courses/typescript-crash-course/overview"},{"title":"TypeScript Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/typescript-crash-course/fundamentals"},{"title":"Functions \u0026 Types","sidebarTitle":"2. Functions \u0026 Types","icon":"function","href":"/courses/typescript-crash-course/functions-types"},{"title":"Objects \u0026 Interfaces","sidebarTitle":"3. Objects \u0026 Interfaces","icon":"object-group","href":"/courses/typescript-crash-course/objects-interfaces"},{"title":"Classes \u0026 OOP","sidebarTitle":"4. Classes \u0026 OOP","icon":"sitemap","href":"/courses/typescript-crash-course/classes-oop"},{"title":"Advanced Types","sidebarTitle":"5. Advanced Types","icon":"layer-group","href":"/courses/typescript-crash-course/advanced-types"},{"title":"Generics Deep Dive","sidebarTitle":"6. Generics","icon":"puzzle-piece","href":"/courses/typescript-crash-course/generics"},{"title":"Modules \u0026 Configuration","sidebarTitle":"7. Modules \u0026 Config","icon":"gear","href":"/courses/typescript-crash-course/modules-config"}]},{"group":"Python","icon":"python","pages":[{"title":"Python Crash Course","sidebarTitle":"Overview","icon":"python","href":"/courses/python-crash-course/overview"},{"title":"Python Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/python-crash-course/fundamentals"},{"title":"Data Structures","sidebarTitle":"2. Data Structures","icon":"layer-group","href":"/courses/python-crash-course/data-structures"},{"title":"Object-Oriented Programming","sidebarTitle":"3. OOP","icon":"object-group","href":"/courses/python-crash-course/oop"},{"title":"Modules \u0026 Packages","sidebarTitle":"4. Modules","icon":"box","href":"/courses/python-crash-course/modules-packages"},{"title":"Advanced Python","sidebarTitle":"5. Advanced","icon":"wand-magic-sparkles","href":"/courses/python-crash-course/advanced"}]},{"group":"Node.js","icon":"node","pages":[{"title":"01. Introduction \u0026 Setup","href":"/courses/node-crash-course/01-intro-setup"},{"title":"02. Modules System","href":"/courses/node-crash-course/02-modules"},{"title":"03. File System","href":"/courses/node-crash-course/03-file-system"},{"title":"04. Events \u0026 EventEmitter","href":"/courses/node-crash-course/04-events"},{"title":"05. HTTP Module \u0026 Web Server","href":"/courses/node-crash-course/05-http-server"},{"title":"06. Streams \u0026 Buffers","href":"/courses/node-crash-course/06-streams-buffers"},{"title":"07. NPM (Node Package Manager)","href":"/courses/node-crash-course/07-npm"},{"title":"07b. Building and Publishing an NPM Package","href":"/courses/node-crash-course/07b-building-npm-package"},{"title":"08. Express.js Basics","href":"/courses/node-crash-course/08-express-basics"},{"title":"09. Building a REST API","href":"/courses/node-crash-course/09-rest-api"},{"title":"10. Deployment \u0026 Best Practices","href":"/courses/node-crash-course/10-deployment"},{"title":"11. Authentication with JWT","href":"/courses/node-crash-course/11-auth-jwt"},{"title":"12. MongoDB \u0026 Mongoose ORM","href":"/courses/node-crash-course/12-mongo-mongoose"},{"title":"13. PostgreSQL \u0026 Prisma ORM","href":"/courses/node-crash-course/13-postgres-prisma"},{"title":"14. Error Handling \u0026 Debugging","href":"/courses/node-crash-course/14-error-handling"},{"title":"15. Testing with Jest","href":"/courses/node-crash-course/15-testing"},{"title":"16. Real-Time with WebSockets","href":"/courses/node-crash-course/16-websockets"},{"title":"17. Security Best Practices","href":"/courses/node-crash-course/17-security"},{"title":"18. Performance \u0026 Caching","href":"/courses/node-crash-course/18-performance"},{"title":"19. Microservices Architecture","href":"/courses/node-crash-course/19-microservices"},{"title":"20. TypeScript with Node.js","href":"/courses/node-crash-course/20-typescript"},{"title":"21. Worker Threads \u0026 Child Processes","href":"/courses/node-crash-course/21-worker-threads"},{"title":"22. Capstone Project: Full-Stack API","href":"/courses/node-crash-course/22-capstone"}]},{"group":"React","icon":"react","pages":[{"title":"01. Introduction to React \u0026 JSX","href":"/courses/react-crash-course/01-intro-jsx"},{"title":"02. Components \u0026 Props","href":"/courses/react-crash-course/02-components-props"},{"title":"03. State \u0026 useState Hook","href":"/courses/react-crash-course/03-state-hook"},{"title":"04. Handling Events","href":"/courses/react-crash-course/04-events"},{"title":"05. Lists \u0026 Keys","href":"/courses/react-crash-course/05-lists-keys"},{"title":"06. Forms \u0026 Controlled Components","href":"/courses/react-crash-course/06-forms"},{"title":"07. useEffect \u0026 Side Effects","href":"/courses/react-crash-course/07-useeffect"},{"title":"08. Context API","href":"/courses/react-crash-course/08-context-api"},{"title":"09. React Router","href":"/courses/react-crash-course/09-react-router"},{"title":"10. Performance Optimization","href":"/courses/react-crash-course/10-optimization"},{"title":"11. Authentication \u0026 Protected Routes","href":"/courses/react-crash-course/11-authentication"},{"title":"12. Redux \u0026 State Management","href":"/courses/react-crash-course/12-redux-state"}]},{"group":"React Native","icon":"mobile","pages":[{"title":"React Native Enterprise Mastery","icon":"mobile","href":"/courses/react-native-crash-course/overview"},{"title":"01. Introduction \u0026 Architecture","href":"/courses/react-native-crash-course/01-intro-architecture"},{"title":"02. Environment Setup","href":"/courses/react-native-crash-course/02-environment-setup"},{"title":"03. Project Structure \u0026 Best Practices","href":"/courses/react-native-crash-course/03-project-structure"},{"title":"04. TypeScript in React Native","href":"/courses/react-native-crash-course/04-typescript"},{"title":"05. Core Components Deep Dive","href":"/courses/react-native-crash-course/05-core-components"},{"title":"6. Styling \u0026 Theming","href":"/courses/react-native-crash-course/06-styling-theming"},{"title":"7. Flexbox Mastery","href":"/courses/react-native-crash-course/07-flexbox-mastery"},{"title":"8. Navigation Fundamentals","href":"/courses/react-native-crash-course/08-navigation-fundamentals"},{"title":"9. Advanced Navigation","href":"/courses/react-native-crash-course/09-navigation-advanced"},{"title":"10. State Management","href":"/courses/react-native-crash-course/10-state-management"},{"title":"11. Redux \u0026 Zustand","href":"/courses/react-native-crash-course/11-redux-zustand"},{"title":"15. React Query \u0026 Data Fetching","href":"/courses/react-native-crash-course/15-react-query"},{"title":"27. Unit Testing","href":"/courses/react-native-crash-course/27-unit-testing"},{"title":"31. Security Best Practices","href":"/courses/react-native-crash-course/31-security"},{"title":"35. Profiling \u0026 Monitoring","href":"/courses/react-native-crash-course/35-profiling"},{"title":"40. CI/CD Pipelines","href":"/courses/react-native-crash-course/40-ci-cd"},{"title":"51. Capstone Project","href":"/courses/react-native-crash-course/51-capstone"}]},{"group":"MongoDB","icon":"database","pages":[{"title":"01. Introduction to NoSQL \u0026 MongoDB","href":"/courses/mongodb-crash-course/01-intro-nosql"},{"title":"02. Installation \u0026 MongoDB Compass","href":"/courses/mongodb-crash-course/02-setup-compass"},{"title":"03. Databases \u0026 Collections","href":"/courses/mongodb-crash-course/03-databases-collections"},{"title":"04. CRUD: Create","href":"/courses/mongodb-crash-course/04-crud-create"},{"title":"05. CRUD: Read (Query Operators)","href":"/courses/mongodb-crash-course/05-crud-read"},{"title":"06. CRUD: Update","href":"/courses/mongodb-crash-course/06-crud-update"},{"title":"07. CRUD: Delete","href":"/courses/mongodb-crash-course/07-crud-delete"},{"title":"08. Aggregation Framework","href":"/courses/mongodb-crash-course/08-aggregation"},{"title":"09. Indexing \u0026 Performance","href":"/courses/mongodb-crash-course/09-indexing"},{"title":"10. Mongoose (ODM) Basics","href":"/courses/mongodb-crash-course/10-mongoose"}]},{"group":"Angular Master Course","icon":"angular","pages":[{"title":"Angular Master Course","icon":"angular","href":"/courses/angular-crash-course/00-overview"},{"title":"01. Introduction \u0026 Setup","icon":"rocket","href":"/courses/angular-crash-course/01-introduction"},{"title":"02. Components \u0026 Templates","icon":"puzzle-piece","href":"/courses/angular-crash-course/02-components"},{"title":"03. Directives \u0026 Pipes","icon":"wand-magic-sparkles","href":"/courses/angular-crash-course/03-directives-pipes"},{"title":"04. Services \u0026 Dependency Injection","icon":"syringe","href":"/courses/angular-crash-course/04-services-di"},{"title":"05. Angular Signals","icon":"signal","href":"/courses/angular-crash-course/05-signals"},{"title":"06. Routing \u0026 Navigation","icon":"route","href":"/courses/angular-crash-course/06-routing"},{"title":"07. Angular Forms","icon":"input-text","href":"/courses/angular-crash-course/07-forms"},{"title":"08. HTTP Client \u0026 RxJS","icon":"server","href":"/courses/angular-crash-course/08-http-rxjs"},{"title":"09. RxJS Deep Dive","icon":"arrows-rotate","href":"/courses/angular-crash-course/09-rxjs"},{"title":"10. Change Detection \u0026 Performance","icon":"gauge-high","href":"/courses/angular-crash-course/10-change-detection"},{"title":"11. Testing in Angular","icon":"vial","href":"/courses/angular-crash-course/11-testing"},{"title":"12. Advanced Patterns","icon":"diagram-project","href":"/courses/angular-crash-course/12-advanced-patterns"},{"title":"13. Server-Side Rendering","icon":"server","href":"/courses/angular-crash-course/13-ssr"},{"title":"14. Security Best Practices","icon":"shield-halved","href":"/courses/angular-crash-course/14-security"},{"title":"15. Capstone Project","icon":"rocket","href":"/courses/angular-crash-course/15-capstone"},{"title":"16. Standalone Components Deep Dive","icon":"cube","href":"/courses/angular-crash-course/16-standalone"},{"title":"17. NgRx State Management","icon":"database","href":"/courses/angular-crash-course/17-ngrx"},{"title":"18. Angular Animations","icon":"wand-magic-sparkles","href":"/courses/angular-crash-course/18-animations"},{"title":"19. Internationalization (i18n)","icon":"globe","href":"/courses/angular-crash-course/19-i18n"},{"title":"20. Accessibility (a11y)","icon":"universal-access","href":"/courses/angular-crash-course/20-accessibility"},{"title":"21. Angular Material \u0026 CDK","icon":"palette","href":"/courses/angular-crash-course/21-material"},{"title":"22. PWA \u0026 Service Workers","icon":"mobile-screen","href":"/courses/angular-crash-course/22-pwa"},{"title":"23. Deployment \u0026 CI/CD","icon":"rocket","href":"/courses/angular-crash-course/23-deployment"},{"title":"24. Micro-frontends with Module Federation","icon":"cubes","href":"/courses/angular-crash-course/24-micro-frontends"},{"title":"25. Nx Monorepo","icon":"boxes-stacked","href":"/courses/angular-crash-course/25-nx-monorepo"},{"title":"26. Performance Optimization","icon":"gauge-high","href":"/courses/angular-crash-course/26-performance"},{"title":"27. Content Projection","icon":"layer-group","href":"/courses/angular-crash-course/27-content-projection"},{"title":"28. Dynamic Components","icon":"wand-magic-sparkles","href":"/courses/angular-crash-course/28-dynamic-components"},{"title":"29. Custom Schematics","icon":"toolbox","href":"/courses/angular-crash-course/29-custom-schematics"},{"title":"30. Error Handling","icon":"triangle-exclamation","href":"/courses/angular-crash-course/30-error-handling"},{"title":"31. Interview Questions","icon":"comments-question","href":"/courses/angular-crash-course/31-interview-questions"},{"title":"32. Best Practices","icon":"award","href":"/courses/angular-crash-course/32-best-practices"},{"title":"33. Enterprise Capstone Project","icon":"building","href":"/courses/angular-crash-course/33-enterprise-capstone"}]}]},{"group":"AI Engineering","icon":"robot","pages":[{"title":"AI Engineering","icon":"robot","href":"/ai-engineering/overview"},{"title":"Python Crash Course","icon":"python","href":"/ai-engineering/python-crash-course"},{"title":"FastAPI Crash Course","icon":"bolt","href":"/ai-engineering/fastapi-crash-course"},{"title":"Databases \u0026 ORM Crash Course","icon":"database","href":"/ai-engineering/databases-crash-course"},{"title":"LLM Fundamentals","icon":"brain","href":"/ai-engineering/llm-fundamentals"},{"title":"Prompt Engineering","icon":"wand-magic-sparkles","href":"/ai-engineering/prompt-engineering"},{"title":"OpenAI API","icon":"bolt","href":"/ai-engineering/openai-api"},{"title":"Structured Outputs","icon":"brackets-curly","href":"/ai-engineering/structured-outputs"},{"title":"Embeddings Deep Dive","icon":"vector-square","href":"/ai-engineering/embeddings"},{"title":"AI Streaming","icon":"water","href":"/ai-engineering/streaming"},{"title":"Vector Databases","icon":"database","href":"/ai-engineering/vector-databases"},{"title":"RAG Systems","icon":"magnifying-glass","href":"/ai-engineering/rag"},{"title":"Types of RAG","icon":"layer-group","href":"/ai-engineering/rag-types"},{"title":"Fine-Tuning LLMs","icon":"sliders","href":"/ai-engineering/fine-tuning"},{"title":"AI Agents","icon":"robot","href":"/ai-engineering/agents"},{"title":"Tool Calling \u0026 Function Calling","icon":"wrench","href":"/ai-engineering/tool-calling"},{"title":"LLM Memory Systems","icon":"brain","href":"/ai-engineering/llm-memory-systems"},{"title":"Multi-Agent Design Patterns","icon":"users-gear","href":"/ai-engineering/multi-agent-patterns"},{"title":"LangChain","icon":"link","href":"/ai-engineering/langchain"},{"title":"LangGraph","icon":"diagram-project","href":"/ai-engineering/langgraph"},{"title":"Model Context Protocol (MCP)","icon":"plug","href":"/ai-engineering/mcp"},{"title":"Agentic Architecture","icon":"sitemap","href":"/ai-engineering/agentic-architecture"},{"title":"Open Source \u0026 Local LLMs","icon":"server","href":"/ai-engineering/open-source-llms"},{"title":"Multimodal AI","icon":"photo-film","href":"/ai-engineering/multimodal-ai"},{"title":"DSPy Framework","icon":"code","href":"/ai-engineering/dspy"},{"title":"Prompt Management \u0026 Versioning","icon":"code-branch","href":"/ai-engineering/prompt-management"},{"title":"LLM Caching","icon":"database","href":"/ai-engineering/llm-caching"},{"title":"Error Handling \u0026 Resilience","icon":"shield-halved","href":"/ai-engineering/error-handling"},{"title":"Batch Processing \u0026 Rate Limiting","icon":"layer-group","href":"/ai-engineering/batch-processing"},{"title":"LLM Fallbacks \u0026 Model Routing","icon":"arrows-split-up-and-left","href":"/ai-engineering/llm-fallbacks"},{"title":"AI Observability \u0026 Monitoring","icon":"chart-line","href":"/ai-engineering/observability-monitoring"},{"title":"AI Security \u0026 Guardrails","icon":"shield-halved","href":"/ai-engineering/ai-security-guardrails"},{"title":"Cost Optimization \u0026 Token Management","icon":"coins","href":"/ai-engineering/cost-optimization"},{"title":"Function Calling Deep Dive","icon":"function","href":"/ai-engineering/function-calling"},{"title":"LLM Orchestration","icon":"sitemap","href":"/ai-engineering/llm-orchestration"},{"title":"Semantic Search \u0026 Retrieval","icon":"magnifying-glass","href":"/ai-engineering/semantic-search"},{"title":"Context Window Management","icon":"window-maximize","href":"/ai-engineering/context-management"},{"title":"Testing LLM Applications","icon":"flask-vial","href":"/ai-engineering/llm-testing"},{"title":"Production Logging \u0026 Debugging","icon":"file-lines","href":"/ai-engineering/production-logging"},{"title":"API Design for AI Applications","icon":"code","href":"/ai-engineering/api-design"},{"title":"Document Processing","icon":"file-lines","href":"/ai-engineering/document-processing"},{"title":"Model Comparison","icon":"scale-balanced","href":"/ai-engineering/model-comparison"},{"title":"Anthropic Claude API","icon":"message-bot","href":"/ai-engineering/anthropic-api"},{"title":"Async Patterns for LLMs","icon":"arrows-spin","href":"/ai-engineering/async-patterns"},{"title":"Advanced Prompting Techniques","icon":"brain","href":"/ai-engineering/advanced-prompting"},{"title":"Output Validation","icon":"shield-check","href":"/ai-engineering/output-validation"},{"title":"Semantic Routing","icon":"route","href":"/ai-engineering/semantic-routing"},{"title":"Advanced RAG Techniques","icon":"layer-group","href":"/ai-engineering/advanced-rag"},{"title":"Voice and Audio AI","icon":"microphone","href":"/ai-engineering/voice-audio"},{"title":"Image Generation","icon":"image","href":"/ai-engineering/image-generation"},{"title":"Summarization Systems","icon":"compress","href":"/ai-engineering/summarization"},{"title":"Chatbot Design Patterns","icon":"comments","href":"/ai-engineering/chatbot-patterns"},{"title":"Knowledge Graphs with LLMs","icon":"diagram-project","href":"/ai-engineering/knowledge-graphs"},{"title":"Synthetic Data Generation","icon":"database","href":"/ai-engineering/synthetic-data"},{"title":"Text Classification","icon":"tags","href":"/ai-engineering/classification"},{"title":"Model Optimization","icon":"gauge-high","href":"/ai-engineering/model-optimization"},{"title":"Realtime AI Applications","icon":"bolt","href":"/ai-engineering/realtime-ai"},{"title":"Evaluation \u0026 Testing","icon":"vial","href":"/ai-engineering/evaluation-testing"},{"title":"Deployment \u0026 Scaling","icon":"rocket","href":"/ai-engineering/deployment-scaling"},{"title":"Capstone Project","icon":"trophy","href":"/ai-engineering/capstone-project"}]},{"group":"Math for ML - Understanding Linear Algebra","icon":"square-root-variable","pages":[{"title":"Introduction to Linear Algebra for ML","sidebarTitle":"Introduction","icon":"rocket","href":"/courses/math-for-ml-linear-algebra/01-introduction"},{"title":"Vectors: The Language of Similarity","sidebarTitle":"Vectors","icon":"arrow-right","href":"/courses/math-for-ml-linear-algebra/02-vectors"},{"title":"Matrices \u0026 Linear Transformations","sidebarTitle":"Matrices","icon":"grid","href":"/courses/math-for-ml-linear-algebra/03-matrices"},{"title":"Project: Image Similarity Search Engine","sidebarTitle":"Project 1","icon":"code","href":"/courses/math-for-ml-linear-algebra/04-project-image-search"},{"title":"Eigenvalues \u0026 Eigenvectors","sidebarTitle":"Eigenvalues","icon":"compass","href":"/courses/math-for-ml-linear-algebra/05-eigenvalues"},{"title":"Principal Component Analysis (PCA)","sidebarTitle":"PCA","icon":"compress","href":"/courses/math-for-ml-linear-algebra/06-pca"},{"title":"Singular Value Decomposition (SVD)","sidebarTitle":"SVD","icon":"layer-group","href":"/courses/math-for-ml-linear-algebra/07-svd"},{"title":"Linear Systems \u0026 Applications","sidebarTitle":"Linear Systems","icon":"diagram-project","href":"/courses/math-for-ml-linear-algebra/08-linear-systems"},{"title":"Project: Music Recommendation Engine","sidebarTitle":"Project 2","icon":"music","href":"/courses/math-for-ml-linear-algebra/09-project-recommender"},{"title":"Orthogonality \u0026 Projections","sidebarTitle":"Orthogonality","icon":"right-left","href":"/courses/math-for-ml-linear-algebra/10-orthogonality"}]},{"group":"Probability \u0026 Statistics for ML","icon":"chart-bar","pages":[{"title":"Probability and Statistics for Machine Learning","sidebarTitle":"Introduction","icon":"chart-line","href":"/courses/statistics-for-ml/01-introduction"},{"title":"Describing Data: What's Normal?","sidebarTitle":"Describing Data","icon":"chart-bar","href":"/courses/statistics-for-ml/02-describing-data"},{"title":"Probability Foundations: How Likely Is This?","sidebarTitle":"Probability","icon":"dice","href":"/courses/statistics-for-ml/03-probability"},{"title":"Probability Distributions: Patterns in Randomness","sidebarTitle":"Distributions","icon":"chart-bell","href":"/courses/statistics-for-ml/04-distributions"},{"title":"Statistical Inference: Conclusions from Samples","sidebarTitle":"Inference","icon":"magnifying-glass-chart","href":"/courses/statistics-for-ml/05-inference"},{"title":"Hypothesis Testing: Real Effect or Random Noise?","sidebarTitle":"Hypothesis Testing","icon":"scale-balanced","href":"/courses/statistics-for-ml/06-hypothesis-testing"},{"title":"Correlation and Regression: Relationships and Predictions","sidebarTitle":"Regression","icon":"chart-line-up","href":"/courses/statistics-for-ml/07-regression"},{"title":"From Statistics to Machine Learning","sidebarTitle":"Stats to ML","icon":"brain","href":"/courses/statistics-for-ml/08-statistics-to-ml"},{"title":"Bayesian Statistics","sidebarTitle":"Bayesian Statistics","icon":"brain-circuit","href":"/courses/statistics-for-ml/09-bayesian-statistics"},{"title":"Time Series Fundamentals","sidebarTitle":"Time Series","icon":"chart-line","href":"/courses/statistics-for-ml/10-time-series-basics"},{"title":"Capstone Project: Complete Statistical Analysis","sidebarTitle":"Capstone Project","icon":"graduation-cap","href":"/courses/statistics-for-ml/11-capstone-project"}]},{"group":"Math for ML - Understanding Calculus","icon":"function","pages":[{"title":"Calculus for Machine Learning","sidebarTitle":"Introduction","icon":"function","href":"/courses/math-for-ml-calculus/00-introduction"},{"title":"Derivatives \u0026 Rates of Change","sidebarTitle":"Derivatives","icon":"chart-line","href":"/courses/math-for-ml-calculus/01-derivatives"},{"title":"Gradients \u0026 Multivariable Calculus","sidebarTitle":"Gradients","icon":"mountain","href":"/courses/math-for-ml-calculus/02-gradients"},{"title":"Chain Rule \u0026 Backpropagation","sidebarTitle":"Chain Rule","icon":"link","href":"/courses/math-for-ml-calculus/03-chain-rule"},{"title":"Gradient Descent","sidebarTitle":"Gradient Descent","icon":"arrow-trend-down","href":"/courses/math-for-ml-calculus/04-gradient-descent"},{"title":"Optimization Techniques","sidebarTitle":"Optimization","icon":"rocket","href":"/courses/math-for-ml-calculus/05-optimization"},{"title":"Final Project: Build a Neural Network","sidebarTitle":"Final Project","icon":"flag-checkered","href":"/courses/math-for-ml-calculus/06-final-project"},{"title":"Automatic Differentiation","sidebarTitle":"Autodiff","icon":"wand-magic-sparkles","href":"/courses/math-for-ml-calculus/07-automatic-differentiation"},{"title":"Convex Optimization","sidebarTitle":"Convexity","icon":"bowl-rice","href":"/courses/math-for-ml-calculus/08-convexity"},{"title":"Real-World Applications","sidebarTitle":"Applications","icon":"industry","href":"/courses/math-for-ml-calculus/09-real-world-applications"}]},{"group":"ML Mastery","icon":"brain","pages":[{"title":"Machine Learning Mastery","sidebarTitle":"Introduction","icon":"brain","href":"/courses/ml-mastery/00-introduction"},{"title":"The Prediction Game","sidebarTitle":"Prediction Game","icon":"crosshairs","href":"/courses/ml-mastery/01-prediction-game"},{"title":"Learning From Mistakes","sidebarTitle":"Learning From Mistakes","icon":"graduation-cap","href":"/courses/ml-mastery/02-learning-from-mistakes"},{"title":"Linear Regression","sidebarTitle":"Linear Regression","icon":"chart-line","href":"/courses/ml-mastery/03-linear-regression"},{"title":"Classification","sidebarTitle":"Classification","icon":"tags","href":"/courses/ml-mastery/04-classification"},{"title":"K-Nearest Neighbors","sidebarTitle":"K-Nearest Neighbors","icon":"people-arrows","href":"/courses/ml-mastery/04a-knn"},{"title":"Decision Trees","sidebarTitle":"Decision Trees","icon":"sitemap","href":"/courses/ml-mastery/05-decision-trees"},{"title":"Support Vector Machines","sidebarTitle":"SVM","icon":"border-none","href":"/courses/ml-mastery/05a-svm"},{"title":"Naive Bayes","sidebarTitle":"Naive Bayes","icon":"percent","href":"/courses/ml-mastery/05b-naive-bayes"},{"title":"Ensemble Methods","sidebarTitle":"Ensemble Methods","icon":"people-group","href":"/courses/ml-mastery/06-ensemble-methods"},{"title":"Model Evaluation","sidebarTitle":"Model Evaluation","icon":"chart-column","href":"/courses/ml-mastery/07-model-evaluation"},{"title":"Feature Engineering","sidebarTitle":"Feature Engineering","icon":"wand-magic-sparkles","href":"/courses/ml-mastery/08-feature-engineering"},{"title":"Hyperparameter Tuning","sidebarTitle":"Hyperparameter Tuning","icon":"sliders","href":"/courses/ml-mastery/09-hyperparameter-tuning"},{"title":"End-to-End ML Project","sidebarTitle":"End-to-End Project","icon":"rocket","href":"/courses/ml-mastery/10-end-to-end-project"},{"title":"Clustering","sidebarTitle":"Clustering","icon":"object-group","href":"/courses/ml-mastery/11-clustering"},{"title":"Neural Networks","sidebarTitle":"Neural Networks","icon":"network-wired","href":"/courses/ml-mastery/12-neural-networks"},{"title":"Regularization","sidebarTitle":"Regularization","icon":"shield-halved","href":"/courses/ml-mastery/13-regularization"},{"title":"Model Deployment","sidebarTitle":"Deployment","icon":"rocket","href":"/courses/ml-mastery/14-model-deployment"},{"title":"Time Series Forecasting","sidebarTitle":"Time Series","icon":"clock","href":"/courses/ml-mastery/15-time-series"},{"title":"Bias-Variance Tradeoff","sidebarTitle":"Bias-Variance","icon":"scale-balanced","href":"/courses/ml-mastery/16-bias-variance"},{"title":"Data Leakage","sidebarTitle":"Data Leakage","icon":"droplet","href":"/courses/ml-mastery/17-data-leakage"},{"title":"Dimensionality Reduction","sidebarTitle":"Dimensionality Reduction","icon":"compress","href":"/courses/ml-mastery/18-dimensionality-reduction"},{"title":"Capstone Project","sidebarTitle":"Capstone Project","icon":"graduation-cap","href":"/courses/ml-mastery/19-capstone-project"},{"title":"Handling Imbalanced Data","sidebarTitle":"Imbalanced Data","icon":"scale-unbalanced","href":"/courses/ml-mastery/20-imbalanced-data"},{"title":"Model Explainability","sidebarTitle":"Explainability","icon":"lightbulb","href":"/courses/ml-mastery/21-explainability"},{"title":"ML Pipelines","sidebarTitle":"ML Pipelines","icon":"diagram-project","href":"/courses/ml-mastery/22-ml-pipelines"},{"title":"Common ML Mistakes","sidebarTitle":"Common Mistakes","icon":"triangle-exclamation","href":"/courses/ml-mastery/23-common-mistakes"},{"title":"Cross-Validation Strategies","sidebarTitle":"Cross-Validation","icon":"layer-group","href":"/courses/ml-mastery/24-cross-validation"},{"title":"Anomaly Detection","sidebarTitle":"Anomaly Detection","icon":"magnifying-glass-chart","href":"/courses/ml-mastery/25-anomaly-detection"},{"title":"ML at Scale","sidebarTitle":"ML at Scale","icon":"server","href":"/courses/ml-mastery/26-ml-at-scale"}]},{"group":"Deep Learning Mastery","icon":"network-wired","pages":[{"title":"Deep Learning Mastery","sidebarTitle":"Overview","icon":"brain-circuit","href":"/courses/deep-learning-mastery/00-overview"},{"title":"The Deep Learning Landscape","sidebarTitle":"Deep Learning Landscape","icon":"map","href":"/courses/deep-learning-mastery/01-landscape"},{"title":"Perceptrons \u0026 Multi-Layer Networks","sidebarTitle":"Perceptrons \u0026 MLPs","icon":"circle-nodes","href":"/courses/deep-learning-mastery/02-perceptrons-mlp"},{"title":"Backpropagation Deep Dive","sidebarTitle":"Backpropagation","icon":"arrows-rotate","href":"/courses/deep-learning-mastery/03-backpropagation"},{"title":"Activation Functions","sidebarTitle":"Activation Functions","icon":"bolt","href":"/courses/deep-learning-mastery/04-activation-functions"},{"title":"Loss Functions \u0026 Objectives","sidebarTitle":"Loss Functions","icon":"crosshairs","href":"/courses/deep-learning-mastery/05-loss-functions"},{"title":"Convolutional Neural Networks","sidebarTitle":"CNNs","icon":"layer-group","href":"/courses/deep-learning-mastery/06-cnns"},{"title":"Pooling, Stride \u0026 CNN Design","sidebarTitle":"CNN Design","icon":"layer-group","href":"/courses/deep-learning-mastery/07-cnn-design"},{"title":"Recurrent Neural Networks","sidebarTitle":"RNNs","icon":"rotate-right","href":"/courses/deep-learning-mastery/08-rnns"},{"title":"LSTMs \u0026 GRUs","sidebarTitle":"LSTMs \u0026 GRUs","icon":"memory","href":"/courses/deep-learning-mastery/09-lstms-grus"},{"title":"Attention Mechanism","sidebarTitle":"Attention","icon":"eye","href":"/courses/deep-learning-mastery/10-attention"},{"title":"Transformers","sidebarTitle":"Transformers","icon":"bolt","href":"/courses/deep-learning-mastery/11-transformers"},{"title":"Generative Adversarial Networks","sidebarTitle":"GANs","icon":"masks-theater","href":"/courses/deep-learning-mastery/12-gans"},{"title":"Autoencoders \u0026 VAEs","sidebarTitle":"Autoencoders","icon":"compress","href":"/courses/deep-learning-mastery/13-autoencoders"},{"title":"Diffusion Models","sidebarTitle":"Diffusion Models","icon":"cloud","href":"/courses/deep-learning-mastery/14-diffusion"},{"title":"Residual \u0026 Skip Connections","sidebarTitle":"Residual Networks","icon":"diagram-project","href":"/courses/deep-learning-mastery/15-residual-networks"},{"title":"Normalization Techniques","sidebarTitle":"Normalization","icon":"sliders","href":"/courses/deep-learning-mastery/16-normalization"},{"title":"Regularization Techniques","sidebarTitle":"Regularization","icon":"shield","href":"/courses/deep-learning-mastery/17-regularization"},{"title":"Optimization Algorithms","sidebarTitle":"Optimizers","icon":"gauge-high","href":"/courses/deep-learning-mastery/18-optimization"},{"title":"Training Strategies at Scale","sidebarTitle":"Scale Training","icon":"server","href":"/courses/deep-learning-mastery/19-training-strategies"},{"title":"Transfer Learning \u0026 Fine-tuning","sidebarTitle":"Transfer Learning","icon":"arrows-repeat","href":"/courses/deep-learning-mastery/20-transfer-learning"},{"title":"Model Deployment","sidebarTitle":"Deployment","icon":"rocket","href":"/courses/deep-learning-mastery/21-deployment"},{"title":"Debugging Deep Learning","sidebarTitle":"Debugging","icon":"bug","href":"/courses/deep-learning-mastery/22-debugging"},{"title":"Vision Transformers","sidebarTitle":"Vision Transformers","icon":"eye","href":"/courses/deep-learning-mastery/23-vision-transformers"},{"title":"Multimodal Models","sidebarTitle":"Multimodal","icon":"images","href":"/courses/deep-learning-mastery/24-multimodal"},{"title":"Foundation Models \u0026 LLMs","sidebarTitle":"Foundation Models","icon":"brain","href":"/courses/deep-learning-mastery/25-foundation-models"},{"title":"Capstone Project","sidebarTitle":"Capstone","icon":"flag-checkered","href":"/courses/deep-learning-mastery/26-capstone"},{"title":"Mathematical Foundations for Deep Learning","sidebarTitle":"Math Foundations","icon":"square-root-variable","href":"/courses/deep-learning-mastery/27-math-foundations"},{"title":"Weight Initialization Strategies","sidebarTitle":"Weight Initialization","icon":"seedling","href":"/courses/deep-learning-mastery/28-weight-initialization"},{"title":"Gradient Flow Analysis","sidebarTitle":"Gradient Flow","icon":"wave-pulse","href":"/courses/deep-learning-mastery/29-gradient-flow"},{"title":"Advanced CNN Architectures","sidebarTitle":"CNN Architectures","icon":"layer-group","href":"/courses/deep-learning-mastery/30-cnn-architectures"},{"title":"Sequence-to-Sequence Models","sidebarTitle":"Seq2Seq","icon":"arrows-left-right","href":"/courses/deep-learning-mastery/31-seq2seq"},{"title":"Self-Supervised Learning","sidebarTitle":"Self-Supervised Learning","icon":"brain","href":"/courses/deep-learning-mastery/32-self-supervised"},{"title":"Reinforcement Learning for Deep Learning","sidebarTitle":"RL for Deep Learning","icon":"gamepad","href":"/courses/deep-learning-mastery/33-rl-for-dl"},{"title":"Neural Architecture Search","sidebarTitle":"Neural Architecture Search","icon":"magnifying-glass","href":"/courses/deep-learning-mastery/34-nas"},{"title":"Interpretability \u0026 Explainability","sidebarTitle":"Interpretability","icon":"eye","href":"/courses/deep-learning-mastery/35-interpretability"},{"title":"Adversarial Robustness","sidebarTitle":"Adversarial ML","icon":"shield-halved","href":"/courses/deep-learning-mastery/36-adversarial-robustness"},{"title":"Efficient Neural Network Architectures","sidebarTitle":"Efficient Architectures","icon":"bolt","href":"/courses/deep-learning-mastery/37-efficient-architectures"},{"title":"Graph Neural Networks","sidebarTitle":"Graph Networks","icon":"diagram-project","href":"/courses/deep-learning-mastery/38-graph-neural-networks"},{"title":"3D Deep Learning","sidebarTitle":"3D Deep Learning","icon":"cube","href":"/courses/deep-learning-mastery/39-3d-deep-learning"},{"title":"Object Detection Deep Dive","sidebarTitle":"Object Detection","icon":"vector-square","href":"/courses/deep-learning-mastery/40-object-detection"},{"title":"Semantic Segmentation","sidebarTitle":"Segmentation","icon":"object-group","href":"/courses/deep-learning-mastery/41-semantic-segmentation"},{"title":"Hyperparameter Tuning","sidebarTitle":"Hyperparameter Tuning","icon":"sliders","href":"/courses/deep-learning-mastery/42-hyperparameter-tuning"},{"title":"Reproducibility","sidebarTitle":"Reproducibility","icon":"repeat","href":"/courses/deep-learning-mastery/43-reproducibility"},{"title":"Memory-Efficient Training","sidebarTitle":"Memory-Efficient Training","icon":"memory","href":"/courses/deep-learning-mastery/44-memory-efficient-training"},{"title":"Quantization Deep Dive","sidebarTitle":"Quantization Deep Dive","icon":"compress","href":"/courses/deep-learning-mastery/45-quantization-deep-dive"},{"title":"Knowledge Distillation","sidebarTitle":"Knowledge Distillation","icon":"school","href":"/courses/deep-learning-mastery/46-knowledge-distillation"},{"title":"Continual Learning","sidebarTitle":"Continual Learning","icon":"arrows-rotate","href":"/courses/deep-learning-mastery/47-continual-learning"}]},{"group":"NestJS Mastery","icon":"feather","pages":[{"title":"NestJS Mastery","sidebarTitle":"Course Overview","icon":"node","href":"/courses/nestjs/overview"},{"title":"NestJS Fundamentals","sidebarTitle":"1. Fundamentals","icon":"book","href":"/courses/nestjs/fundamentals"},{"title":"Dependency Injection","sidebarTitle":"2. DI \u0026 Modules","icon":"puzzle-piece","href":"/courses/nestjs/dependency-injection"},{"title":"Controllers \u0026 Routing","sidebarTitle":"3. Controllers","icon":"route","href":"/courses/nestjs/controllers-routes"},{"title":"Providers \u0026 Services","sidebarTitle":"4. Providers","icon":"gear","href":"/courses/nestjs/providers-services"},{"title":"Database Integration","sidebarTitle":"5. Database","icon":"database","href":"/courses/nestjs/database-integration"},{"title":"Authentication \u0026 Authorization","sidebarTitle":"6. Auth","icon":"lock","href":"/courses/nestjs/authentication-authorization"},{"title":"Testing","sidebarTitle":"7. Testing","icon":"flask","href":"/courses/nestjs/testing"},{"title":"Microservices","sidebarTitle":"8. Microservices","icon":"cubes","href":"/courses/nestjs/microservices"},{"title":"Deployment \u0026 Production","sidebarTitle":"9. Deployment","icon":"rocket","href":"/courses/nestjs/deployment-production"},{"title":"Advanced Patterns","sidebarTitle":"10. Advanced","icon":"star","description":null,"href":"/courses/nestjs/advanced-patterns"}]},{"group":"Microservices Mastery","icon":"cubes","pages":[{"title":"Microservices Mastery","sidebarTitle":"Course Overview","icon":"cubes","href":"/courses/microservices-mastery/00-overview"},{"title":"1. Microservices Foundations","description":"Understand when and why to use microservices, monolith vs microservices tradeoffs, and key architectural principles","href":"/courses/microservices-mastery/01-foundations"},{"title":"2. Domain-Driven Design","href":"/courses/microservices-mastery/02-domain-driven-design"},{"title":"3. Synchronous Communication","href":"/courses/microservices-mastery/03-sync-communication"},{"title":"4. Asynchronous Communication","href":"/courses/microservices-mastery/04-async-communication"},{"title":"5. API Gateway Pattern","href":"/courses/microservices-mastery/05-api-gateway"},{"title":"6. Data Management Patterns","href":"/courses/microservices-mastery/06-data-management"},{"title":"7. Resilience Patterns","href":"/courses/microservices-mastery/07-resilience-patterns"},{"title":"8. Service Discovery","href":"/courses/microservices-mastery/08-service-discovery"},{"title":"9. Observability","href":"/courses/microservices-mastery/09-observability"},{"title":"10. Security","href":"/courses/microservices-mastery/10-security"},{"title":"11. Containerization with Docker","href":"/courses/microservices-mastery/11-containerization"},{"title":"12. Kubernetes Deployment","href":"/courses/microservices-mastery/12-kubernetes"},{"title":"13. Testing Strategies","href":"/courses/microservices-mastery/13-testing"},{"title":"14. Interview Preparation","href":"/courses/microservices-mastery/14-interview-prep"},{"title":"15. Capstone Project","href":"/courses/microservices-mastery/15-capstone"},{"title":"16. Service Mesh","href":"/courses/microservices-mastery/16-service-mesh"},{"title":"17. Configuration Management","href":"/courses/microservices-mastery/17-configuration-management"},{"title":"18. CI/CD for Microservices","href":"/courses/microservices-mastery/18-cicd"},{"title":"19. Database Patterns","href":"/courses/microservices-mastery/19-database-patterns"},{"title":"20. Caching Strategies","href":"/courses/microservices-mastery/20-caching-strategies"},{"title":"21. Chaos Engineering","href":"/courses/microservices-mastery/21-chaos-engineering"},{"title":"22. Case Studies","href":"/courses/microservices-mastery/22-case-studies"},{"title":"23. Load Balancing Deep Dive","href":"/courses/microservices-mastery/23-load-balancing"},{"title":"24. Migration Patterns","href":"/courses/microservices-mastery/24-migration-patterns"},{"title":"25. Event Sourcing Deep Dive","href":"/courses/microservices-mastery/25-event-sourcing-deep-dive"},{"title":"26. GraphQL Federation","href":"/courses/microservices-mastery/26-graphql-federation"}]},{"group":"Low Level Design","pages":[{"title":"Low Level Design (LLD)","icon":"cubes","href":"/lld/overview"},{"title":"LLD Interview Cheat Sheet","icon":"file-lines","href":"/lld/interview-cheatsheet"}]},{"group":"OOP Concepts","pages":[{"title":"What is OOP?","icon":"graduation-cap","href":"/lld/oop/introduction"},{"title":"Encapsulation","icon":"box","href":"/lld/oop/encapsulation"},{"title":"Inheritance","icon":"sitemap","href":"/lld/oop/inheritance"},{"title":"Polymorphism","icon":"shapes","href":"/lld/oop/polymorphism"},{"title":"Abstraction","icon":"eye-slash","href":"/lld/oop/abstraction"},{"title":"OOP Concepts","icon":"object-group","href":"/lld/oop-concepts"}]},{"group":"SOLID Principles","pages":[{"title":"SOLID Introduction","icon":"wand-magic-sparkles","href":"/lld/solid/introduction"},{"title":"Single Responsibility Principle","icon":"user-check","href":"/lld/solid/srp"},{"title":"Open/Closed Principle","icon":"plug","href":"/lld/solid/ocp"},{"title":"Liskov Substitution Principle","icon":"right-left","href":"/lld/solid/lsp"},{"title":"Interface Segregation Principle","icon":"puzzle-piece","href":"/lld/solid/isp"},{"title":"Dependency Inversion Principle","icon":"outlet","href":"/lld/solid/dip"},{"title":"SOLID Principles in Practice","icon":"compass-drafting","href":"/lld/solid-practice"}]},{"group":"Design Patterns","pages":[{"title":"Design Patterns","icon":"shapes","href":"/lld/design-patterns"},{"title":"UML Diagrams","icon":"diagram-project","href":"/lld/uml-diagrams"}]},{"group":"LLD Case Studies","pages":[{"title":"Case Study: Parking Lot System","icon":"square-parking","href":"/lld/case-parking-lot"},{"title":"Case Study: Library Management System","icon":"book","href":"/lld/case-library"},{"title":"Design Vending Machine","icon":"box","href":"/lld/case-vending-machine"},{"title":"Design LRU Cache","icon":"database","href":"/lld/case-lru-cache"},{"title":"Design Movie Ticket Booking System","icon":"ticket","href":"/lld/case-movie-ticket"},{"title":"Case Study: Elevator System","icon":"elevator","href":"/lld/case-elevator"},{"title":"Case Study: Chess Game","icon":"chess","href":"/lld/case-chess"},{"title":"Case Study: Hotel Booking System","icon":"hotel","href":"/lld/case-hotel-booking"},{"title":"Case Study: ATM System","icon":"building-columns","href":"/lld/case-atm"}]},{"group":"System Design (HLD)","pages":[{"title":"System Design Mastery","icon":"network-wired","href":"/system-design/overview"},{"title":"Interview Guide \u0026 Cheatsheet","icon":"clipboard-check","href":"/system-design/interview-guide"},{"title":"Interview Questions Bank","icon":"clipboard-question","href":"/system-design/interview-questions"},{"title":"System Design Fundamentals","icon":"book","href":"/system-design/fundamentals"},{"title":"System Design Building Blocks","icon":"cubes","href":"/system-design/building-blocks"},{"title":"Networking Fundamentals","icon":"network-wired","href":"/system-design/networking"},{"title":"Database Design","icon":"database","href":"/system-design/databases"},{"title":"API Design","icon":"plug","href":"/system-design/api-design"},{"title":"Distributed Systems","icon":"share-nodes","href":"/system-design/distributed-systems"},{"title":"Microservices Architecture","icon":"cubes","href":"/system-design/microservices"},{"title":"Back-of-Envelope Calculations","icon":"calculator","href":"/system-design/estimations"}]},{"group":"Senior Level (L5+/Staff)","pages":[{"title":"Advanced Concepts","icon":"brain","href":"/system-design/advanced-concepts"},{"title":"Scalability Patterns","icon":"arrow-up-right-dots","href":"/system-design/scalability-patterns"},{"title":"Reliability \u0026 Fault Tolerance","icon":"shield-halved","href":"/system-design/reliability-patterns"},{"title":"Observability \u0026 Monitoring","icon":"chart-line","href":"/system-design/observability"},{"title":"Data Pipelines","icon":"pipe","href":"/system-design/data-pipelines"},{"title":"Security Patterns","icon":"shield","href":"/system-design/security-patterns"}]},{"group":"HLD Case Studies","pages":[{"title":"Design: URL Shortener","icon":"link","href":"/system-design/case-url-shortener"},{"title":"Design: Rate Limiter","icon":"gauge","href":"/system-design/case-rate-limiter"},{"title":"Design a Notification System","icon":"bell","href":"/system-design/case-notification-system"},{"title":"Design: Twitter/X Timeline","icon":"twitter","href":"/system-design/case-twitter"},{"title":"Design: WhatsApp/Messenger","icon":"message","href":"/system-design/case-whatsapp"},{"title":"Design a Payment System","icon":"credit-card","href":"/system-design/case-payment-system"},{"title":"Design: Netflix/YouTube","icon":"video","href":"/system-design/case-netflix"},{"title":"Design: Uber/Lyft","icon":"car","href":"/system-design/case-uber"},{"title":"Design Google Maps","icon":"map-location-dot","href":"/system-design/case-google-maps"}]},{"group":"Engineering Fundamentals","pages":[{"title":"Engineering Topics","icon":"gears","href":"/engineering/overview"},{"title":"Computer Science Fundamentals","icon":"microchip","href":"/engineering/cs-fundamentals"},{"title":"Software Design Principles","icon":"compass-drafting","href":"/engineering/design-principles"},{"title":"Architecture Patterns","icon":"building","href":"/engineering/architecture-patterns"}]},{"group":"DevOps \u0026 Operations","pages":[{"title":"DevOps \u0026 Infrastructure","icon":"server","href":"/engineering/devops"},{"title":"Security Fundamentals","icon":"shield-halved","href":"/engineering/security"},{"title":"Performance \u0026 Optimization","icon":"gauge-high","href":"/engineering/performance"}]},{"group":"Azure Cloud Engineering","icon":"cloud","pages":[{"title":"Azure Cloud Engineering","sidebarTitle":"Overview","icon":"cloud","href":"/courses/azure-cloud-engineering/00-overview"},{"title":"Azure Fundamentals \u0026 Architecture","icon":"cloud-arrow-up","href":"/courses/azure-cloud-engineering/01-azure-fundamentals"},{"title":"Identity \u0026 Access Management","icon":"user-shield","href":"/courses/azure-cloud-engineering/02-identity-access-management"},{"title":"03a. Networking Fundamentals","icon":"network-wired","href":"/courses/azure-cloud-engineering/03a-networking-fundamentals"},{"title":"03b. Hybrid \u0026 Enterprise","icon":"globe","href":"/courses/azure-cloud-engineering/03b-hybrid-networking"},{"title":"03c. Traffic \u0026 Security","icon":"traffic-light","href":"/courses/azure-cloud-engineering/03c-traffic-management"},{"title":"Compute Services","icon":"server","href":"/courses/azure-cloud-engineering/04-compute-services"},{"title":"Storage Solutions","icon":"database","href":"/courses/azure-cloud-engineering/05-storage-solutions"},{"title":"Database Services","icon":"database","href":"/courses/azure-cloud-engineering/06-database-services"},{"title":"Azure Kubernetes Service (AKS)","icon":"dharmachakra","href":"/courses/azure-cloud-engineering/07-container-kubernetes"},{"title":"Serverless Architecture","icon":"bolt","href":"/courses/azure-cloud-engineering/08-serverless-architecture"},{"title":"Monitoring \u0026 Observability","icon":"chart-line","href":"/courses/azure-cloud-engineering/09-monitoring-observability"},{"title":"Security \u0026 Compliance","icon":"shield-halved","href":"/courses/azure-cloud-engineering/10-security-compliance"},{"title":"DevOps \u0026 CI/CD","icon":"code-branch","href":"/courses/azure-cloud-engineering/11-devops-cicd"},{"title":"Cost Optimization","icon":"dollar-sign","href":"/courses/azure-cloud-engineering/12-cost-optimization"},{"title":"High Availability \u0026 Disaster Recovery","icon":"life-ring","href":"/courses/azure-cloud-engineering/13-high-availability-dr"},{"title":"Architecture Patterns","icon":"diagram-project","href":"/courses/azure-cloud-engineering/14-architecture-patterns"},{"title":"Capstone Project","icon":"trophy","href":"/courses/azure-cloud-engineering/15-capstone-project"},{"title":"API Management \u0026 Messaging Patterns","icon":"diagram-project","href":"/courses/azure-cloud-engineering/16-api-messaging"},{"title":"SRE \u0026 Production Excellence","icon":"shield-heart","href":"/courses/azure-cloud-engineering/17-sre-production"}]},{"group":"AWS Cloud","icon":"cloud","pages":[{"title":"AWS Cloud Mastery","icon":"cloud","href":"/aws/overview"},{"title":"Core Concepts","icon":"circle-nodes","href":"/aws/core-concepts"},{"title":"Compute Services","icon":"microchip","href":"/aws/compute"},{"title":"Storage \u0026 Databases","icon":"hard-drive","href":"/aws/storage-databases"},{"title":"Networking","icon":"diagram-project","href":"/aws/networking"},{"title":"Security \u0026 IAM","icon":"shield-halved","href":"/aws/security"},{"title":"Well-Architected Framework","icon":"building","href":"/aws/well-architected"}]},{"group":"AWS Monitoring \u0026 Observability","icon":"chart-line","pages":[{"title":"Amazon CloudWatch","icon":"chart-line","href":"/aws/cloudwatch"},{"title":"AWS X-Ray","icon":"microscope","href":"/aws/xray"},{"title":"Observability \u0026 Monitoring","icon":"chart-line","href":"/aws/observability"}]},{"group":"AWS Security Services","icon":"shield-halved","pages":[{"title":"AWS GuardDuty","icon":"shield","href":"/aws/guardduty"},{"title":"AWS Security Hub","icon":"building-shield","href":"/aws/security-hub"},{"title":"AWS Inspector","href":"/aws/inspector"},{"title":"AWS WAF (Web Application Firewall)","href":"/aws/waf"},{"title":"AWS Shield","href":"/aws/shield"},{"title":"AWS CloudTrail","icon":"file-lines","href":"/aws/cloudtrail"},{"title":"AWS Config","icon":"gear","href":"/aws/config"}]},{"group":"AWS Serverless","icon":"bolt","pages":[{"title":"AWS Lambda","icon":"bolt","href":"/aws/lambda"},{"title":"AWS Step Functions","icon":"diagram-project","href":"/aws/step-functions"},{"title":"AWS SAM","icon":"box","href":"/aws/sam"},{"title":"Amazon DynamoDB","icon":"database","href":"/aws/dynamodb"}]},{"group":"AWS Operations","icon":"gears","pages":[{"title":"DevOps \u0026 CI/CD","icon":"code-branch","href":"/aws/devops-cicd"}]},{"group":"AWS Advanced","icon":"rocket","pages":[{"title":"CDN \u0026 Edge Services","icon":"globe","href":"/aws/cdn-edge"},{"title":"Messaging \u0026 Integration","icon":"arrows-split-up-and-left","href":"/aws/messaging"},{"title":"Containers \u0026 Microservices","icon":"cubes","href":"/aws/containers"}]},{"group":"AWS Case Studies","icon":"lightbulb","pages":[{"title":"Case Study: Serverless URL Shortener","icon":"bolt","href":"/aws/case-study-serverless"}]},{"group":"GCP Cloud Engineering","icon":"cloud","pages":[{"title":"GCP Cloud Engineering","sidebarTitle":"Overview","icon":"cloud","href":"/courses/gcp-cloud-engineering/00-overview"},{"title":"GCP Fundamentals","href":"/courses/gcp-cloud-engineering/01-gcp-fundamentals"},{"title":"Identity \u0026 Security","href":"/courses/gcp-cloud-engineering/02-iam-security"},{"title":"Networking \u0026 VPC","href":"/courses/gcp-cloud-engineering/03-networking-vpc"},{"title":"Load Balancing \u0026 DNS","href":"/courses/gcp-cloud-engineering/04-load-balancing-dns"},{"title":"Compute Engine","href":"/courses/gcp-cloud-engineering/05-compute-engine"},{"title":"Cloud Storage","href":"/courses/gcp-cloud-engineering/06-cloud-storage"},{"title":"Relational Databases","href":"/courses/gcp-cloud-engineering/07-relational-databases"},{"title":"NoSQL Databases","href":"/courses/gcp-cloud-engineering/08-nosql-databases"},{"title":"Containers \u0026 Artifacts","href":"/courses/gcp-cloud-engineering/09-containers-registry"},{"title":"Google Kubernetes Engine","href":"/courses/gcp-cloud-engineering/10-google-kubernetes-engine"},{"title":"Serverless Compute","href":"/courses/gcp-cloud-engineering/11-serverless-compute"},{"title":"Data Analytics \u0026 BigQuery","href":"/courses/gcp-cloud-engineering/12-data-analytics-bigquery"},{"title":"Monitoring \u0026 Observability","href":"/courses/gcp-cloud-engineering/13-monitoring-observability"},{"title":"Security \u0026 Compliance","href":"/courses/gcp-cloud-engineering/14-security-compliance"},{"title":"IaC \u0026 Deployment","href":"/courses/gcp-cloud-engineering/15-iac-deployment"},{"title":"Hybrid \u0026 Multi-Cloud","href":"/courses/gcp-cloud-engineering/16-hybrid-multi-cloud"},{"title":"Cost Management","href":"/courses/gcp-cloud-engineering/17-cost-management"},{"title":"Capstone Project","href":"/courses/gcp-cloud-engineering/18-capstone-project"}]},{"group":"DevOps Tools","icon":"toolbox","pages":[{"title":"DevOps Tools Mastery","sidebarTitle":"Overview","icon":"toolbox","href":"/courses/devops-tools/overview"},{"group":"Git Crash Course","pages":[{"title":"Git Crash Course","sidebarTitle":"Git Overview","icon":"code-branch","href":"/courses/devops-tools/git-overview"},{"title":"Git Fundamentals","sidebarTitle":"Fundamentals","icon":"book","href":"/courses/devops-tools/git-fundamentals"},{"title":"Git Branching \u0026 Merging","sidebarTitle":"Branching","icon":"code-branch","href":"/courses/devops-tools/git-branching"},{"title":"Git Collaboration","sidebarTitle":"Collaboration","icon":"users","href":"/courses/devops-tools/git-collaboration"},{"title":"Git Advanced Topics","sidebarTitle":"Advanced","icon":"wand-magic-sparkles","href":"/courses/devops-tools/git-advanced"},{"title":"Git Workflows","sidebarTitle":"Workflows","icon":"code-branch","href":"/courses/devops-tools/git-workflows"},{"title":"Git Hooks \u0026 Automation","sidebarTitle":"Hooks \u0026 Automation","icon":"robot","href":"/courses/devops-tools/git-hooks"}]},{"group":"Linux Crash Course","pages":[{"title":"Linux Crash Course","sidebarTitle":"Linux Overview","icon":"linux","href":"/courses/devops-tools/linux-overview"},{"title":"Linux Fundamentals","sidebarTitle":"Fundamentals","icon":"terminal","href":"/courses/devops-tools/linux-fundamentals"},{"title":"Linux Permissions \u0026 Users","sidebarTitle":"Permissions","icon":"lock","href":"/courses/devops-tools/linux-permissions"},{"title":"Linux Process Management","sidebarTitle":"Processes","icon":"gears","href":"/courses/devops-tools/linux-processes"},{"title":"Linux Networking","sidebarTitle":"Networking","icon":"network-wired","href":"/courses/devops-tools/linux-networking"},{"title":"Linux Shell Scripting","sidebarTitle":"Shell Scripting","icon":"file-code","href":"/courses/devops-tools/linux-scripting"},{"title":"System Monitoring","sidebarTitle":"Monitoring","icon":"chart-line","href":"/courses/devops-tools/linux-monitoring"},{"title":"Security Hardening","sidebarTitle":"Security","icon":"lock","href":"/courses/devops-tools/linux-security"}]},{"group":"Docker Crash Course","pages":[{"title":"Docker Crash Course","sidebarTitle":"Docker Overview","icon":"docker","href":"/courses/devops-tools/docker-overview"},{"title":"Docker Fundamentals","sidebarTitle":"Fundamentals","icon":"book","href":"/courses/devops-tools/docker-fundamentals"},{"title":"Building Docker Images","sidebarTitle":"Images","icon":"layer-group","href":"/courses/devops-tools/docker-images"},{"title":"Docker Networking \u0026 Volumes","sidebarTitle":"Networking","icon":"network-wired","href":"/courses/devops-tools/docker-networking"},{"title":"Docker Compose","sidebarTitle":"Compose","icon":"cubes","href":"/courses/devops-tools/docker-compose"},{"title":"Docker Best Practices","sidebarTitle":"Best Practices","icon":"shield-check","href":"/courses/devops-tools/docker-best-practices"}]},{"group":"RabbitMQ Crash Course","pages":[{"title":"RabbitMQ Crash Course","sidebarTitle":"RabbitMQ Overview","icon":"rabbit","href":"/courses/devops-tools/rabbitmq-overview"},{"title":"RabbitMQ Fundamentals","sidebarTitle":"Fundamentals","icon":"book","href":"/courses/devops-tools/rabbitmq-fundamentals"},{"title":"Patterns","sidebarTitle":"Patterns","icon":"rabbit","href":"/courses/devops-tools/rabbitmq-patterns"},{"title":"Reliability","sidebarTitle":"Reliability","icon":"rabbit","href":"/courses/devops-tools/rabbitmq-reliability"}]},{"group":"Kafka Crash Course","pages":[{"title":"Kafka Crash Course","sidebarTitle":"Kafka Overview","icon":"stream","href":"/courses/devops-tools/kafka-overview"},{"title":"Kafka Fundamentals","sidebarTitle":"Fundamentals","icon":"book","href":"/courses/devops-tools/kafka-fundamentals"},{"title":"Kafka Producers \u0026 Consumers","sidebarTitle":"Producers \u0026 Consumers","icon":"arrows-left-right","href":"/courses/devops-tools/kafka-producers-consumers"},{"title":"Kafka Streams","sidebarTitle":"Streams","icon":"water","href":"/courses/devops-tools/kafka-streams"},{"title":"Kafka Operations","sidebarTitle":"Operations","icon":"server","href":"/courses/devops-tools/kafka-operations"}]},{"group":"Kubernetes Crash Course","pages":[{"title":"Kubernetes Crash Course","sidebarTitle":"Kubernetes Overview","icon":"dharmachakra","href":"/courses/devops-tools/kubernetes-overview"},{"title":"Kubernetes Fundamentals","sidebarTitle":"Fundamentals","icon":"book","href":"/courses/devops-tools/kubernetes-fundamentals"},{"title":"Kubernetes Workloads","sidebarTitle":"Workloads","icon":"cubes","href":"/courses/devops-tools/kubernetes-workloads"},{"title":"Kubernetes Services","sidebarTitle":"Services","icon":"network-wired","href":"/courses/devops-tools/kubernetes-services"},{"title":"Kubernetes Configuration","sidebarTitle":"Configuration","icon":"gear","href":"/courses/devops-tools/kubernetes-config"},{"title":"Kubernetes Storage","sidebarTitle":"Storage","icon":"hard-drive","href":"/courses/devops-tools/kubernetes-storage"},{"title":"Kubernetes on Windows \u0026 Linux","sidebarTitle":"Windows \u0026 Linux","icon":"window-maximize","href":"/courses/devops-tools/kubernetes-windows-linux"}]}]},{"group":"Database Engineering","icon":"database","pages":[{"title":"Database Engineering Mastery","sidebarTitle":"Course Overview","icon":"database","href":"/courses/database-engineering/overview"},{"group":"Track 1: Foundations","pages":[{"title":"SQL Foundations","sidebarTitle":"1. SQL Foundations","icon":"terminal","href":"/courses/database-engineering/sql-foundations"},{"title":"Database Design \u0026 Modeling","sidebarTitle":"2. Database Design","icon":"diagram-project","href":"/courses/database-engineering/database-design"},{"title":"Transactions \u0026 ACID","sidebarTitle":"3. Transactions \u0026 ACID","icon":"shield-check","href":"/courses/database-engineering/transactions"}]},{"group":"Track 2: Performance","pages":[{"title":"Indexing Deep Dive","sidebarTitle":"4. Indexing Deep Dive","icon":"magnifying-glass-chart","href":"/courses/database-engineering/indexing"},{"title":"Query Optimization","sidebarTitle":"5. Query Optimization","icon":"bolt","href":"/courses/database-engineering/query-optimization"},{"title":"Query Execution Plans Mastery","sidebarTitle":"Execution Plans Deep Dive","icon":"route","href":"/courses/database-engineering/execution-plans-mastery"},{"title":"Performance Engineering","sidebarTitle":"Performance Engineering","icon":"gauge-high","href":"/courses/database-engineering/performance-engineering"}]},{"group":"Track 3: Internals","pages":[{"title":"PostgreSQL Internals","sidebarTitle":"6. PostgreSQL Internals","icon":"microchip","href":"/courses/database-engineering/internals"},{"title":"PostgreSQL Data Structures","sidebarTitle":"Data Structures","icon":"sitemap","href":"/courses/database-engineering/data-structures"},{"title":"Query Processing Pipeline","sidebarTitle":"8. Query Processing","icon":"gears","href":"/courses/database-engineering/query-processing"},{"title":"Query Engine Deep Dive","sidebarTitle":"Query Engine Internals","icon":"microchip","href":"/courses/database-engineering/query-engine-deep-dive"},{"title":"PostgreSQL Architecture","sidebarTitle":"9. PG Architecture","icon":"sitemap","href":"/courses/database-engineering/architecture"},{"title":"Storage Engine Deep Dive","sidebarTitle":"Storage Engine Internals","icon":"hard-drive","href":"/courses/database-engineering/storage-deep-dive"}]},{"group":"Track 4: Distributed","pages":[{"title":"Replication \u0026 High Availability","sidebarTitle":"7. Replication \u0026 HA","icon":"server","href":"/courses/database-engineering/replication"},{"title":"Scaling Strategies","sidebarTitle":"8. Scaling","icon":"chart-line","href":"/courses/database-engineering/scaling"},{"title":"Distributed Database Systems","sidebarTitle":"Distributed Systems","icon":"network-wired","href":"/courses/database-engineering/distributed-systems"}]},{"group":"OSS Contributions","pages":[{"title":"PostgreSQL Source Code","sidebarTitle":"13. Source Code","icon":"code","href":"/courses/database-engineering/source-code"},{"title":"Contributing to PostgreSQL","sidebarTitle":"14. Contributing","icon":"code-pull-request","href":"/courses/database-engineering/contributing"}]},{"group":"Capstone","pages":[{"title":"Senior Interview Mastery","sidebarTitle":"15. Interview Prep","icon":"user-tie","href":"/courses/database-engineering/interview-prep"},{"title":"System Design Case Studies","sidebarTitle":"16. Case Studies","icon":"building","href":"/courses/database-engineering/case-studies"}]}]},{"group":"HIPAA Compliance Mastery","icon":"shield-check","pages":[{"title":"HIPAA Compliance Mastery","sidebarTitle":"Course Overview","icon":"hospital","href":"/courses/hipaa-compliance/overview"},{"group":"Track 1: Regulatory Foundations","pages":[{"title":"HIPAA Fundamentals","sidebarTitle":"HIPAA Fundamentals","icon":"book-medical","href":"/courses/hipaa-compliance/hipaa-fundamentals"},{"title":"HIPAA Risk Assessment","sidebarTitle":"Risk Assessment","icon":"magnifying-glass-chart","href":"/courses/hipaa-compliance/risk-assessment"},{"title":"PDPL \u0026 Global Data Protection","sidebarTitle":"PDPL Compliance","icon":"globe","href":"/courses/hipaa-compliance/pdpl-compliance"}]},{"group":"Track 2: Security Architecture","pages":[{"title":"Access Control Systems","sidebarTitle":"Access Control","icon":"user-shield","href":"/courses/hipaa-compliance/access-control"},{"title":"Encryption: Data at Rest \u0026 In Transit","sidebarTitle":"Encryption","icon":"lock","href":"/courses/hipaa-compliance/encryption"},{"title":"HIPAA Database Security \u0026 Encryption","href":"/courses/hipaa-compliance/database-security"}]},{"group":"Track 3: Implementation","pages":[{"title":"Audit Logging for HIPAA","sidebarTitle":"Audit Logging","icon":"file-lines","href":"/courses/hipaa-compliance/audit-logging"},{"title":"E2E Encryption with AI Agents","sidebarTitle":"E2E Encryption + AI","icon":"robot","href":"/courses/hipaa-compliance/e2e-encryption-ai"},{"title":"Implementation Guide","sidebarTitle":"Implementation Guide","icon":"code","href":"/courses/hipaa-compliance/implementation-guide"}]},{"group":"Track 4: Operations \u0026 Governance","pages":[{"title":"Incident Response for Healthcare","sidebarTitle":"Incident Response","icon":"siren","href":"/courses/hipaa-compliance/incident-response"},{"title":"HIPAA Vendor \u0026 Third-Party Risk Management","href":"/courses/hipaa-compliance/vendor-management"}]},{"group":"Track 5: Advanced Topics","pages":[{"title":"HIPAA Breach Case Studies \u0026 Lessons Learned","href":"/courses/hipaa-compliance/case-studies"},{"title":"Compliance Checklist \u0026 BAA","sidebarTitle":"Compliance Checklist","icon":"clipboard-check","href":"/courses/hipaa-compliance/compliance-checklist"}]},{"group":"Track 6: Capstone","pages":[{"title":"HIPAA Compliance Capstone Project","href":"/courses/hipaa-compliance/capstone-project"}]}]},{"group":"Operating Systems","icon":"microchip","pages":[{"title":"Operating Systems Mastery","sidebarTitle":"Course Overview","icon":"microchip","href":"/operating-systems/overview"},{"title":"OS Fundamentals \u0026 System Call Internals","sidebarTitle":"Fundamentals","icon":"book","href":"/operating-systems/os-fundamentals"},{"title":"CPU Architectures \u0026 Microarchitecture","sidebarTitle":"CPU Architectures","icon":"microchip","href":"/operating-systems/cpu-architectures"},{"title":"Operating System Interfaces","sidebarTitle":"xv6 OS Interfaces","icon":"book-open-reader","href":"/operating-systems/xv6"},{"group":"System Startup","pages":[{"title":"The Boot Process: From Reset Vector to PID 1","sidebarTitle":"Boot Process","icon":"power-off","href":"/operating-systems/boot-process"}]},{"group":"Process Management","pages":[{"title":"Process Management","sidebarTitle":"Processes","icon":"microchip","href":"/operating-systems/processes"},{"title":"Threads \u0026 Concurrency: The Senior Mastery Guide","sidebarTitle":"Threads","icon":"layer-group","href":"/operating-systems/threads"},{"title":"CPU Scheduling","sidebarTitle":"Scheduling","icon":"clock","href":"/operating-systems/scheduling"}]},{"group":"Memory Management","pages":[{"title":"Memory Management","sidebarTitle":"Memory Management","icon":"memory","href":"/operating-systems/memory-management"},{"title":"Virtual Memory","sidebarTitle":"Virtual Memory","icon":"memory","href":"/operating-systems/virtual-memory"}]},{"group":"Concurrency \u0026 I/O","pages":[{"title":"Advanced Synchronization \u0026 RCU","sidebarTitle":"Synchronization","icon":"hand-middle-finger","href":"/operating-systems/synchronization"},{"title":"Deadlocks","sidebarTitle":"Deadlocks","icon":"circle-xmark","href":"/operating-systems/deadlocks"},{"title":"Inter-Process Communication: Kernel Internals \u0026 Architecture","sidebarTitle":"IPC","icon":"message","href":"/operating-systems/ipc"},{"title":"Virtual File System (VFS) \u0026 Disk Internals","sidebarTitle":"File Systems","icon":"file-lines","href":"/operating-systems/file-systems"},{"title":"I/O Systems \u0026 Modern I/O","sidebarTitle":"I/O Systems","icon":"input-pipe","href":"/operating-systems/io-systems"}]},{"group":"Networking","pages":[{"title":"Kernel Networking Stack: From NIC to Socket","sidebarTitle":"Networking","icon":"network-wired","href":"/operating-systems/networking"}]},{"group":"Virtualization","pages":[{"title":"Containers \u0026 Virtualization: From Namespaces to Hypervisors","sidebarTitle":"Containers \u0026 VMs","icon":"cubes","href":"/operating-systems/containers-virtualization"}]},{"group":"Advanced Topics","pages":[{"title":"OS Security: From Hardware to Userspace","sidebarTitle":"Security","icon":"shield-halved","href":"/operating-systems/security"},{"title":"Linux Internals","sidebarTitle":"Linux Internals","icon":"linux","href":"/operating-systems/linux-internals"},{"title":"Modern OS Features","sidebarTitle":"Modern Features","icon":"rocket","href":"/operating-systems/modern-features"},{"title":"Observability \u0026 Performance Engineering","sidebarTitle":"Performance","icon":"gauge-high","href":"/operating-systems/debugging-performance"}]},{"group":"Interview Prep","pages":[{"title":"Interview Preparation","sidebarTitle":"Interview Prep","icon":"user-tie","href":"/operating-systems/interview-prep"},{"title":"OS Case Studies","sidebarTitle":"Case Studies","icon":"building","href":"/operating-systems/case-studies"}]}]},{"group":"Linux Internals","icon":"linux","pages":[{"title":"Linux Internals \u0026 Kernel Mastery","sidebarTitle":"Course Overview","icon":"linux","href":"/courses/linux-internals/overview"},{"group":"Kernel Foundations","pages":[{"title":"Linux Kernel Architecture","sidebarTitle":"Kernel Architecture","icon":"sitemap","href":"/courses/linux-internals/kernel-architecture"},{"title":"System Call Interface","sidebarTitle":"System Calls","icon":"terminal","href":"/courses/linux-internals/syscalls"},{"title":"Kernel Data Structures","sidebarTitle":"Data Structures","icon":"database","href":"/courses/linux-internals/data-structures"},{"title":"Interrupts \u0026 Exception Handling","sidebarTitle":"Interrupts","icon":"bolt","href":"/courses/linux-internals/interrupts-exceptions"},{"title":"Kernel Synchronization","sidebarTitle":"Synchronization","icon":"lock","href":"/courses/linux-internals/synchronization"}]},{"group":"Process \u0026 Memory","pages":[{"title":"Process Subsystem Deep Dive","sidebarTitle":"Process Subsystem","icon":"microchip","href":"/courses/linux-internals/process-subsystem"},{"title":"Memory Management Internals","sidebarTitle":"Memory Management","icon":"memory","href":"/courses/linux-internals/memory-management"},{"title":"Signals \u0026 IPC","sidebarTitle":"Signals \u0026 IPC","icon":"arrows-split-up-and-left","href":"/courses/linux-internals/signals-ipc"}]},{"group":"Containers \u0026 Isolation","pages":[{"title":"Namespaces Deep Dive","sidebarTitle":"Namespaces","icon":"boxes-stacked","href":"/courses/linux-internals/namespaces"},{"title":"Control Groups (cgroups)","sidebarTitle":"cgroups","icon":"object-group","href":"/courses/linux-internals/cgroups"},{"title":"Security Modules \u0026 Capabilities","sidebarTitle":"Security","icon":"shield-halved","href":"/courses/linux-internals/security-modules"}]},{"group":"I/O \u0026 Networking","pages":[{"title":"Filesystem \u0026 VFS","sidebarTitle":"Filesystem \u0026 VFS","icon":"folder-tree","href":"/courses/linux-internals/filesystem-vfs"},{"title":"I/O Subsystem","sidebarTitle":"I/O Subsystem","icon":"hard-drive","href":"/courses/linux-internals/io-subsystem"},{"title":"Network Stack","sidebarTitle":"Network Stack","icon":"network-wired","href":"/courses/linux-internals/networking-stack"}]},{"group":"Observability","pages":[{"title":"eBPF Deep Dive","sidebarTitle":"eBPF","icon":"magnifying-glass-chart","href":"/courses/linux-internals/ebpf"},{"title":"Tracing \u0026 Profiling","sidebarTitle":"Tracing \u0026 Profiling","icon":"chart-line","href":"/courses/linux-internals/tracing-profiling"}]},{"group":"Advanced Kernel","pages":[{"title":"Power \u0026 Thermal Management","sidebarTitle":"Power Management","icon":"bolt","href":"/courses/linux-internals/power-management"}]},{"group":"Interview Prep","pages":[{"title":"Hands-on Projects","sidebarTitle":"Projects","icon":"hammer","href":"/courses/linux-internals/projects"},{"title":"Real Interview Questions","sidebarTitle":"Interview Questions","icon":"clipboard-question","href":"/courses/linux-internals/interview-questions"}]}]},{"group":"Distributed Systems","icon":"sitemap","pages":[{"title":"Distributed Systems Mastery","sidebarTitle":"Course Overview","icon":"network-wired","href":"/courses/distributed-systems/overview"},{"group":"Core Foundations","pages":[{"title":"Foundations of Distributed Systems","sidebarTitle":"Foundations","icon":"book","href":"/courses/distributed-systems/foundations"},{"title":"Distributed Networking Fundamentals","sidebarTitle":"Networking","icon":"network-wired","href":"/courses/distributed-systems/networking"},{"title":"Time \u0026 Clock Synchronization","sidebarTitle":"Clocks","icon":"clock","href":"/courses/distributed-systems/clocks"},{"title":"Consistency Models","sidebarTitle":"Consistency Models","icon":"scale-balanced","href":"/courses/distributed-systems/consistency-models"},{"title":"Distributed Snapshots","sidebarTitle":"Distributed Snapshots","icon":"camera","href":"/courses/distributed-systems/snapshots"}]},{"group":"Consensus \u0026 Replication","pages":[{"title":"Consensus Protocols","sidebarTitle":"Consensus","icon":"handshake","href":"/courses/distributed-systems/consensus"},{"title":"Raft Consensus Deep Dive","sidebarTitle":"Raft Deep Dive","icon":"star","href":"/courses/distributed-systems/raft-deep-dive"},{"title":"Paxos Consensus Deep Dive","sidebarTitle":"Paxos Deep Dive","icon":"scroll","href":"/courses/distributed-systems/paxos-deep-dive"},{"title":"Replication Strategies","sidebarTitle":"Replication","icon":"clone","href":"/courses/distributed-systems/replication"},{"title":"Distributed Coordination","sidebarTitle":"Coordination","icon":"people-group","href":"/courses/distributed-systems/coordination"},{"title":"Byzantine Fault Tolerance (BFT)","sidebarTitle":"Byzantine Fault Tolerance","icon":"shield-halved","href":"/courses/distributed-systems/bft"},{"title":"Gossip Protocols \u0026 Membership","sidebarTitle":"Gossip Protocols","icon":"comments","href":"/courses/distributed-systems/gossip"},{"title":"Formal Verification in Distributed Systems","sidebarTitle":"Formal Verification","icon":"shield-check","href":"/courses/distributed-systems/formal-verification"}]},{"group":"Data \u0026 Transactions","pages":[{"title":"Distributed Transactions","sidebarTitle":"Transactions","icon":"money-bill-transfer","href":"/courses/distributed-systems/transactions"},{"title":"Data Partitioning \u0026 Sharding","sidebarTitle":"Partitioning","icon":"table-cells","href":"/courses/distributed-systems/partitioning"},{"title":"Data Systems at Scale","sidebarTitle":"Data Systems","icon":"database","href":"/courses/distributed-systems/data-systems"}]},{"group":"Infrastructure \u0026 Messaging","pages":[{"title":"Distributed Messaging \u0026 Event Systems","sidebarTitle":"Messaging","icon":"envelope","href":"/courses/distributed-systems/messaging"},{"title":"Distributed Caching","sidebarTitle":"Caching","icon":"bolt","href":"/courses/distributed-systems/caching"},{"title":"Fault Tolerance Patterns","sidebarTitle":"Fault Tolerance","icon":"shield-heart","href":"/courses/distributed-systems/fault-tolerance"}]},{"group":"Production \u0026 Practice","pages":[{"title":"Production Excellence","sidebarTitle":"Production","icon":"shield-halved","href":"/courses/distributed-systems/production"},{"title":"Real-World Case Studies","sidebarTitle":"Case Studies","icon":"building","href":"/courses/distributed-systems/case-studies"},{"title":"Interview Practice Problems","sidebarTitle":"Interview Problems","icon":"comments","href":"/courses/distributed-systems/interview-problems"}]}]},{"group":"Networking Mastery","icon":"network-wired","pages":[{"title":"Networking Fundamentals","sidebarTitle":"1. Overview","icon":"globe","href":"/courses/networking-mastery/01-overview"},{"group":"Fundamentals","pages":[{"title":"Network Models","sidebarTitle":"2. OSI \u0026 TCP/IP","icon":"layer-group","href":"/courses/networking-mastery/02-models"},{"title":"Physical \u0026 Data Link Layers","sidebarTitle":"3. Physical \u0026 Data Link","icon":"ethernet","href":"/courses/networking-mastery/03-physical-datalink"},{"title":"Network Layer","sidebarTitle":"4. Network Layer","icon":"network-wired","href":"/courses/networking-mastery/04-network-layer"},{"title":"Transport Layer","sidebarTitle":"5. Transport Layer","icon":"truck-fast","href":"/courses/networking-mastery/05-transport-layer"},{"title":"Application Layer","sidebarTitle":"6. Application Layer","icon":"browser","href":"/courses/networking-mastery/06-application-layer"}]},{"group":"Security \u0026 Advanced Intro","pages":[{"title":"Network Security","sidebarTitle":"7. Security","icon":"shield-check","href":"/courses/networking-mastery/07-security"},{"title":"Advanced Networking Intro","sidebarTitle":"8. Advanced Topics","icon":"cloud","href":"/courses/networking-mastery/08-advanced"}]},{"group":"Deep Dives","pages":[{"title":"IP Addressing Deep Dive","sidebarTitle":"9. IP Addressing Mastery","icon":"map-location-dot","href":"/courses/networking-mastery/09-ip-addressing-deep-dive"},{"title":"NAT \u0026 PAT Deep Dive","sidebarTitle":"10. NAT Mastery","icon":"right-left","href":"/courses/networking-mastery/10-nat-deep-dive"},{"title":"Routing Deep Dive","sidebarTitle":"11. Routing Mastery","icon":"route","href":"/courses/networking-mastery/11-routing-deep-dive"},{"title":"DNS Deep Dive","sidebarTitle":"12. DNS Mastery","icon":"book","href":"/courses/networking-mastery/12-dns-deep-dive"},{"title":"Load Balancing \u0026 Proxies","sidebarTitle":"13. Load Balancing","icon":"scale-balanced","href":"/courses/networking-mastery/13-load-balancing"}]},{"group":"Operations \u0026 Security","pages":[{"title":"Network Troubleshooting","sidebarTitle":"14. Troubleshooting","icon":"wrench","href":"/courses/networking-mastery/14-troubleshooting"},{"title":"VPNs \u0026 Tunneling","sidebarTitle":"15. VPNs \u0026 Tunneling","icon":"tunnel","href":"/courses/networking-mastery/15-vpn-tunneling"},{"title":"Firewalls \u0026 Security Groups","sidebarTitle":"17. Firewalls","icon":"shield-halved","href":"/courses/networking-mastery/17-firewalls-security-groups"}]},{"group":"Modern Networking","pages":[{"title":"Container Networking","sidebarTitle":"18. Container Networking","icon":"cubes","href":"/courses/networking-mastery/18-container-networking"},{"title":"Real-World Networking Scenarios","sidebarTitle":"16. Network Scenarios","icon":"diagram-project","href":"/courses/networking-mastery/16-scenarios"}]}]},{"group":"Build Your Own X","icon":"hammer","pages":[{"title":"Build Your Own X","sidebarTitle":"Course Overview","icon":"hammer","href":"/courses/build-your-own-x/overview"},{"group":"Build Your Own Git","pages":[{"title":"Build Your Own Git","sidebarTitle":"Git Overview","icon":"code-branch","href":"/courses/build-your-own-x/git-overview"},{"title":"Chapter 1: Project Setup \u0026 Init","sidebarTitle":"1. Setup \u0026 Init","icon":"folder-open","href":"/courses/build-your-own-x/git-1-setup"},{"title":"Chapter 2: The Object Model","sidebarTitle":"2. Object Model","icon":"cube","href":"/courses/build-your-own-x/git-2-objects"},{"title":"Chapter 3: Staging \u0026 Index","sidebarTitle":"3. Staging \u0026 Index","icon":"layer-plus","href":"/courses/build-your-own-x/git-3-staging"},{"title":"Chapter 4: Commits \u0026 History","sidebarTitle":"4. Commits \u0026 History","icon":"code-commit","href":"/courses/build-your-own-x/git-4-commits"},{"title":"Chapter 5: Branches \u0026 Checkout","sidebarTitle":"5. Branches \u0026 Checkout","icon":"code-branch","href":"/courses/build-your-own-x/git-5-branches"}]},{"group":"Build Your Own Redis","pages":[{"title":"Build Your Own Redis","sidebarTitle":"Redis Overview","icon":"database","href":"/courses/build-your-own-x/redis-overview"},{"title":"Chapter 1: RESP Protocol","sidebarTitle":"1. RESP Protocol","icon":"network-wired","href":"/courses/build-your-own-x/redis-1-protocol"},{"title":"Chapter 2: TCP Server","sidebarTitle":"2. TCP Server","icon":"server","href":"/courses/build-your-own-x/redis-2-server"},{"title":"Chapter 3: Data Structures","sidebarTitle":"3. Data Structures","icon":"layer-group","href":"/courses/build-your-own-x/redis-3-data-structures"},{"title":"Chapter 4: Persistence","sidebarTitle":"4. Persistence","icon":"floppy-disk","href":"/courses/build-your-own-x/redis-4-persistence"},{"title":"Chapter 5: Pub/Sub","sidebarTitle":"5. Pub/Sub","icon":"tower-broadcast","href":"/courses/build-your-own-x/redis-5-pubsub"}]},{"group":"Build Your Own Docker","pages":[{"title":"Build Your Own Docker","sidebarTitle":"Docker Overview","icon":"docker","href":"/courses/build-your-own-x/docker-overview"},{"title":"Chapter 1: Linux Namespaces","sidebarTitle":"1. Namespaces","icon":"box","href":"/courses/build-your-own-x/docker-1-namespaces"},{"title":"Chapter 2: Control Groups (cgroups)","sidebarTitle":"2. Cgroups","icon":"gauge-high","href":"/courses/build-your-own-x/docker-2-cgroups"},{"title":"Chapter 3: Filesystem Isolation","sidebarTitle":"3. Filesystem","icon":"folder-tree","href":"/courses/build-your-own-x/docker-3-filesystem"},{"title":"Chapter 4: Container Networking","sidebarTitle":"4. Networking","icon":"network-wired","href":"/courses/build-your-own-x/docker-4-networking"},{"title":"Chapter 5: Container Images","sidebarTitle":"5. Images","icon":"box-archive","href":"/courses/build-your-own-x/docker-5-images"}]}]},{"group":"Go Lang Mastery","icon":"golang","pages":[{"group":"Fundamentals","pages":[{"title":"Introduction to Go","sidebarTitle":"1. Introduction","icon":"golang","href":"/courses/go-lang-mastery/01-introduction"},{"title":"Variables and Types","sidebarTitle":"2. Variables \u0026 Types","icon":"cube","href":"/courses/go-lang-mastery/02-variables-and-types"},{"title":"Control Structures","sidebarTitle":"3. Control Structures","icon":"code-branch","href":"/courses/go-lang-mastery/03-control-structures"},{"title":"Functions and Packages","sidebarTitle":"4. Functions \u0026 Packages","icon":"box-open","href":"/courses/go-lang-mastery/04-functions-and-packages"},{"title":"Arrays, Slices, and Maps","sidebarTitle":"5. Arrays, Slices \u0026 Maps","icon":"layer-group","href":"/courses/go-lang-mastery/05-arrays-slices-maps"},{"title":"Pointers and Structs","sidebarTitle":"6. Pointers \u0026 Structs","icon":"shapes","href":"/courses/go-lang-mastery/06-pointers-and-structs"},{"title":"Interfaces","sidebarTitle":"7. Interfaces","icon":"plug","href":"/courses/go-lang-mastery/07-interfaces"}]},{"group":"Core Concepts","pages":[{"title":"08. Concurrency","icon":"arrows-split-up-and-left","href":"/courses/go-lang-mastery/08-concurrency"},{"title":"09. Error Handling","icon":"triangle-exclamation","href":"/courses/go-lang-mastery/09-error-handling"},{"title":"10. Testing and Benchmarking","icon":"vial","href":"/courses/go-lang-mastery/10-testing-and-benchmarking"},{"title":"Generics","sidebarTitle":"11. Generics","icon":"cube","href":"/courses/go-lang-mastery/11-generics"},{"title":"Advanced Concurrency Patterns","sidebarTitle":"12. Advanced Concurrency","icon":"diagram-project","href":"/courses/go-lang-mastery/12-advanced-concurrency"},{"title":"Context Package","sidebarTitle":"13. Context","icon":"clock","href":"/courses/go-lang-mastery/13-context"}]},{"group":"Production Go","pages":[{"title":"HTTP \u0026 Web Development","sidebarTitle":"14. HTTP \u0026 Web","icon":"globe","href":"/courses/go-lang-mastery/14-http-web"},{"title":"Database Operations","sidebarTitle":"15. Databases","icon":"database","href":"/courses/go-lang-mastery/15-databases"},{"title":"Microservices \u0026 gRPC","sidebarTitle":"16. Microservices \u0026 gRPC","icon":"sitemap","href":"/courses/go-lang-mastery/16-microservices-grpc"},{"title":"Performance Optimization","sidebarTitle":"17. Performance","icon":"gauge-high","href":"/courses/go-lang-mastery/17-performance"},{"title":"Production Best Practices","sidebarTitle":"18. Production","icon":"rocket","href":"/courses/go-lang-mastery/18-production"}]},{"group":"Advanced Topics","pages":[{"title":"Design Patterns in Go","sidebarTitle":"19. Design Patterns","icon":"puzzle-piece","href":"/courses/go-lang-mastery/19-design-patterns"},{"title":"Interview Preparation","sidebarTitle":"20. Interview Prep","icon":"user-tie","href":"/courses/go-lang-mastery/20-interview-prep"}]}]},{"group":"C Programming","icon":"memory","pages":[{"title":"Advanced C Programming for Systems Development","sidebarTitle":"Course Overview","icon":"microchip","href":"/courses/c-programming/overview"},{"group":"Foundations","pages":[{"title":"C Syntax Speed Run","sidebarTitle":"Syntax Speed Run","icon":"forward-fast","href":"/courses/c-programming/syntax-speedrun"},{"title":"Build Systems \u0026 Toolchain","sidebarTitle":"Build \u0026 Toolchain","icon":"hammer","href":"/courses/c-programming/toolchain"},{"title":"Debugging Fundamentals","sidebarTitle":"Debugging","icon":"bug","href":"/courses/c-programming/debugging"}]},{"group":"Memory Mastery","pages":[{"title":"Pointers Deep Dive","sidebarTitle":"Pointers","icon":"arrow-pointer","href":"/courses/c-programming/pointers"},{"title":"Memory Layout \u0026 Segments","sidebarTitle":"Memory Layout","icon":"layer-group","href":"/courses/c-programming/memory-layout"},{"title":"Dynamic Memory Management","sidebarTitle":"Dynamic Memory","icon":"memory","href":"/courses/c-programming/dynamic-memory"},{"title":"Preprocessor Mastery","sidebarTitle":"Preprocessor","icon":"code","href":"/courses/c-programming/preprocessor"},{"title":"Data Structures in C","sidebarTitle":"Data Structures","icon":"sitemap","href":"/courses/c-programming/data-structures"},{"title":"Undefined Behavior","sidebarTitle":"Undefined Behavior","icon":"skull","href":"/courses/c-programming/undefined-behavior"}]},{"group":"Systems Programming","pages":[{"title":"System Calls \u0026 POSIX","sidebarTitle":"System Calls","icon":"terminal","href":"/courses/c-programming/system-calls"},{"title":"Concurrency \u0026 Threading","sidebarTitle":"Concurrency","icon":"arrows-split-up-and-left","href":"/courses/c-programming/concurrency"},{"title":"Network Programming","sidebarTitle":"Networking","icon":"network-wired","href":"/courses/c-programming/networking"}]},{"group":"Projects","pages":[{"title":"Project: Build a Shell","sidebarTitle":"Project: Shell","icon":"terminal","href":"/courses/c-programming/project-shell"},{"title":"Project: Key-Value Store","sidebarTitle":"Project: KV Store","icon":"database","href":"/courses/c-programming/project-database"},{"title":"Project: Memory Allocator","sidebarTitle":"Project: malloc","icon":"memory","href":"/courses/c-programming/project-allocator"},{"title":"Project: HTTP Server","sidebarTitle":"Project: HTTP Server","icon":"server","href":"/courses/c-programming/project-http-server"}]},{"group":"Advanced Topics","pages":[{"title":"Performance Optimization","sidebarTitle":"Performance","icon":"gauge-high","href":"/courses/c-programming/performance"},{"title":"Embedded Systems","sidebarTitle":"Embedded","icon":"microchip","href":"/courses/c-programming/embedded"},{"title":"Linux Kernel Modules","sidebarTitle":"Kernel Modules","icon":"linux","href":"/courses/c-programming/kernel-modules"}]}]},{"group":"Classic Research Papers","icon":"file-lines","pages":[{"group":"Google File System (GFS)","icon":"folder","pages":[{"title":"Google File System","sidebarTitle":"GFS Overview","icon":"database","href":"/courses/engineering-papers/gfs-overview"},{"title":"Introduction and Motivation","sidebarTitle":"Chapter 1: Introduction","icon":"flag","href":"/courses/engineering-papers/chapter-1-introduction"},{"title":"Architecture Overview","sidebarTitle":"Chapter 2: Architecture","icon":"diagram-project","href":"/courses/engineering-papers/chapter-2-architecture"},{"title":"Master Operations","sidebarTitle":"Chapter 3: Master Operations","icon":"crown","href":"/courses/engineering-papers/chapter-3-master-operations"},{"title":"Chunkservers and Data Flow","sidebarTitle":"Chapter 4: Chunkservers \u0026 Data Flow","icon":"server","href":"/courses/engineering-papers/chapter-4-chunkservers-dataflow"},{"title":"Consistency Model","sidebarTitle":"Chapter 5: Consistency Model","icon":"scale-balanced","href":"/courses/engineering-papers/chapter-5-consistency-model"},{"title":"Fault Tolerance","sidebarTitle":"Chapter 6: Fault Tolerance","icon":"shield-halved","href":"/courses/engineering-papers/chapter-6-fault-tolerance"},{"title":"Performance and Optimizations","sidebarTitle":"Chapter 7: Performance","icon":"gauge-high","href":"/courses/engineering-papers/chapter-7-performance"},{"title":"Impact and Evolution","sidebarTitle":"Chapter 8: Impact \u0026 Evolution","icon":"rocket","href":"/courses/engineering-papers/chapter-8-impact-evolution"}]},{"group":"Apache Hadoop","icon":"elephant","pages":[{"title":"Apache Hadoop","sidebarTitle":"Hadoop Overview","icon":"database","href":"/courses/engineering-papers/hadoop-overview"},{"title":"Introduction and Origins","sidebarTitle":"Chapter 1: Introduction","icon":"flag","href":"/courses/engineering-papers/hadoop-chapter-1-introduction"},{"title":"HDFS Architecture","sidebarTitle":"Chapter 2: HDFS","icon":"hard-drive","href":"/courses/engineering-papers/hadoop-chapter-2-hdfs-architecture"},{"title":"MapReduce Framework","sidebarTitle":"Chapter 3: MapReduce","icon":"diagram-project","href":"/courses/engineering-papers/hadoop-chapter-3-mapreduce-framework"},{"title":"YARN: Resource Management","sidebarTitle":"Chapter 4: YARN","icon":"layer-group","href":"/courses/engineering-papers/hadoop-chapter-4-yarn"},{"title":"Hadoop Ecosystem","sidebarTitle":"Chapter 5: Ecosystem","icon":"puzzle-piece","href":"/courses/engineering-papers/hadoop-chapter-5-ecosystem"},{"title":"Fault Tolerance and Reliability","sidebarTitle":"Chapter 6: Fault Tolerance","icon":"shield-check","href":"/courses/engineering-papers/hadoop-chapter-6-fault-tolerance"},{"title":"Performance Tuning and Optimization","sidebarTitle":"Chapter 7: Performance","icon":"gauge-high","href":"/courses/engineering-papers/hadoop-chapter-7-performance"},{"title":"Hadoop in Production","sidebarTitle":"Chapter 8: Production","icon":"server","href":"/courses/engineering-papers/hadoop-chapter-8-production"}]},{"group":"Amazon DynamoDB","icon":"database","pages":[{"title":"Amazon DynamoDB","sidebarTitle":"DynamoDB Overview","icon":"database","href":"/courses/engineering-papers/dynamodb-overview"},{"title":"Introduction and Origins","sidebarTitle":"Chapter 1: Introduction","icon":"flag","href":"/courses/engineering-papers/dynamodb-chapter-1-introduction"},{"title":"Architecture and Partitioning","sidebarTitle":"Chapter 2: Architecture","icon":"sitemap","href":"/courses/engineering-papers/dynamodb-chapter-2-architecture"},{"title":"Data Modeling in DynamoDB","sidebarTitle":"Chapter 3: Data Model","icon":"database","href":"/courses/engineering-papers/dynamodb-chapter-3-data-model"},{"title":"Consistency Models in DynamoDB","sidebarTitle":"Chapter 4: Consistency","icon":"scale-balanced","href":"/courses/engineering-papers/dynamodb-chapter-4-consistency"},{"title":"Performance Optimization in DynamoDB","sidebarTitle":"Chapter 5: Performance","icon":"gauge-high","href":"/courses/engineering-papers/dynamodb-chapter-5-performance"},{"title":"Advanced DynamoDB Features","sidebarTitle":"Chapter 6: Advanced Features","icon":"wand-magic-sparkles","href":"/courses/engineering-papers/dynamodb-chapter-6-advanced-features"},{"title":"Fault Tolerance and Reliability","sidebarTitle":"Chapter 7: Fault Tolerance","icon":"shield-check","href":"/courses/engineering-papers/dynamodb-chapter-7-fault-tolerance"},{"title":"DynamoDB in Production","sidebarTitle":"Chapter 8: Production","icon":"server","href":"/courses/engineering-papers/dynamodb-chapter-8-production"}]}]},{"group":"Distributed System Tools","icon":"server","pages":[{"group":"Apache Hadoop","icon":"elephant","pages":[{"title":"Apache Hadoop Mastery","sidebarTitle":"Hadoop Overview","icon":"elephant","href":"/distributed-systems-tools/hadoop-overview"},{"title":"Introduction \u0026 Foundational Papers","sidebarTitle":"1. Introduction \u0026 Papers","icon":"book-open","href":"/distributed-systems-tools/hadoop-introduction"},{"title":"HDFS Architecture \u0026 Internals","sidebarTitle":"2. HDFS Architecture","icon":"database","href":"/distributed-systems-tools/hadoop-hdfs"},{"title":"Advanced HDFS: Federation, HA \u0026 Erasure Coding","sidebarTitle":"2b. Advanced HDFS","icon":"layer-group","href":"/distributed-systems-tools/hadoop-hdfs-advanced"},{"title":"MapReduce Programming Model","sidebarTitle":"3. MapReduce Programming","icon":"code","href":"/distributed-systems-tools/hadoop-mapreduce"},{"title":"YARN Resource Management","sidebarTitle":"4. YARN Architecture","icon":"layer-group","href":"/distributed-systems-tools/hadoop-yarn"},{"title":"Hadoop Ecosystem \u0026 Integration","sidebarTitle":"5. Ecosystem Tools","icon":"puzzle-piece","href":"/distributed-systems-tools/hadoop-ecosystem"},{"title":"Data Processing Patterns \u0026 Best Practices","sidebarTitle":"6. Processing Patterns","icon":"diagram-project","href":"/distributed-systems-tools/hadoop-patterns"},{"title":"Production Deployment \u0026 Operations","sidebarTitle":"7. Production Operations","icon":"server","href":"/distributed-systems-tools/hadoop-production"},{"title":"Capstone Project: End-to-End Data Pipeline","sidebarTitle":"8. Capstone Project","icon":"trophy","href":"/distributed-systems-tools/hadoop-capstone"}]},{"group":"Apache Spark","icon":"bolt","pages":[{"title":"Apache Spark Mastery","sidebarTitle":"Spark Overview","icon":"bolt","href":"/distributed-systems-tools/spark-overview"},{"title":"Demystifying the RDD Paper: Spark's Foundation","sidebarTitle":"1. RDD Paper Deep-Dive","icon":"book-open","href":"/distributed-systems-tools/spark-introduction"},{"title":"Demystifying RDD Programming: From Theory to Production","sidebarTitle":"2. RDD Programming","icon":"bolt","href":"/distributed-systems-tools/spark-rdd"},{"title":"Spark SQL \u0026 DataFrames","sidebarTitle":"3. Spark SQL","icon":"table","href":"/distributed-systems-tools/spark-sql"},{"title":"Structured Streaming","sidebarTitle":"4. Streaming","icon":"bolt","href":"/distributed-systems-tools/spark-streaming"},{"title":"MLlib for Machine Learning","sidebarTitle":"5. MLlib","icon":"bolt","href":"/distributed-systems-tools/spark-mllib"},{"title":"Performance Tuning","sidebarTitle":"6. Performance Tuning","icon":"bolt","href":"/distributed-systems-tools/spark-tuning"},{"title":"Cluster Deployment","sidebarTitle":"7. Operations","icon":"bolt","href":"/distributed-systems-tools/spark-operations"},{"title":"Advanced Topics","sidebarTitle":"8. Advanced","icon":"bolt","href":"/distributed-systems-tools/spark-advanced"},{"title":"Capstone Project","sidebarTitle":"9. Capstone","icon":"bolt","href":"/distributed-systems-tools/spark-capstone"}]},{"group":"Apache Flink","icon":"wave-pulse","pages":[{"title":"Apache Flink Mastery","sidebarTitle":"Flink Overview","icon":"wave-pulse","href":"/distributed-systems-tools/flink-overview"},{"title":"Demystifying the Dataflow Model: True Stream Processing with Flink","sidebarTitle":"1. Introduction","icon":"wave-pulse","href":"/distributed-systems-tools/flink-introduction"},{"title":"DataStream API","sidebarTitle":"2. DataStream API","icon":"wave-pulse","href":"/distributed-systems-tools/flink-datastream"},{"title":"Event Time \u0026 Watermarks","sidebarTitle":"3. Event Time","icon":"wave-pulse","href":"/distributed-systems-tools/flink-eventtime"},{"title":"Windows \u0026 Time Operations","sidebarTitle":"4. Windows","icon":"wave-pulse","href":"/distributed-systems-tools/flink-windows"},{"title":"Demystifying Stateful Stream Processing: Flink's State Management Deep Dive","sidebarTitle":"5. State \u0026 Timers","icon":"database","href":"/distributed-systems-tools/flink-state"},{"title":"Declarative Stream Processing: Flink SQL \u0026 Table API Deep Dive","sidebarTitle":"6. SQL \u0026 Table API","icon":"table","href":"/distributed-systems-tools/flink-sql"},{"title":"Complex Event Processing: Pattern Detection at Scale with Flink CEP","sidebarTitle":"7. Complex Event Processing","icon":"sitemap","href":"/distributed-systems-tools/flink-cep"},{"title":"Production Flink: Deployment, Operations \u0026 Monitoring at Scale","sidebarTitle":"8. Production Operations","icon":"server","href":"/distributed-systems-tools/flink-operations"},{"title":"Capstone: Production-Grade Real-Time Fraud Detection System","sidebarTitle":"9. Capstone Project","icon":"diagram-project","href":"/distributed-systems-tools/flink-capstone"}]},{"group":"Apache Beam","icon":"diagram-project","pages":[{"title":"Apache Beam Mastery","sidebarTitle":"Beam Overview","icon":"diagram-project","href":"/distributed-systems-tools/beam-overview"},{"title":"Demystifying the Dataflow Model: Write Once, Run Anywhere with Apache Beam","sidebarTitle":"1. Introduction","icon":"diagram-project","href":"/distributed-systems-tools/beam-introduction"},{"title":"Core Programming Model","sidebarTitle":"2. Core Model","icon":"diagram-project","href":"/distributed-systems-tools/beam-core"},{"title":"Windowing \u0026 Time","sidebarTitle":"3. Windowing","icon":"diagram-project","href":"/distributed-systems-tools/beam-windowing"},{"title":"Triggers \u0026 Watermarks","sidebarTitle":"4. Triggers","icon":"diagram-project","href":"/distributed-systems-tools/beam-triggers"},{"title":"State \u0026 Timers","sidebarTitle":"5. State","icon":"diagram-project","href":"/distributed-systems-tools/beam-state"},{"title":"Beam I/O Connectors","sidebarTitle":"6. I/O","icon":"diagram-project","href":"/distributed-systems-tools/beam-io"},{"title":"Beam SQL","sidebarTitle":"7. SQL","icon":"diagram-project","href":"/distributed-systems-tools/beam-sql"},{"title":"Multi-Runner Execution","sidebarTitle":"8. Runners","icon":"diagram-project","href":"/distributed-systems-tools/beam-runners"},{"title":"Capstone Project","sidebarTitle":"9. Capstone","icon":"diagram-project","href":"/distributed-systems-tools/beam-capstone"}]},{"group":"Apache Airflow","icon":"wind","pages":[{"title":"What is Apache Airflow?","sidebarTitle":"Overview","icon":"wind","href":"/distributed-systems-tools/airflow-overview"},{"title":"Airflow Core Concepts","sidebarTitle":"Core Concepts","icon":"diagram-project","href":"/distributed-systems-tools/airflow-core-concepts"},{"title":"Airflow Operators","sidebarTitle":"Operators","icon":"puzzle-piece","href":"/distributed-systems-tools/airflow-operators"},{"title":"Airflow Scheduling","sidebarTitle":"Scheduling","icon":"clock","href":"/distributed-systems-tools/airflow-scheduling"}]},{"group":"Apache Cassandra","icon":"database","pages":[{"title":"Apache Cassandra Mastery","sidebarTitle":"Overview","icon":"database","href":"/distributed-systems-tools/cassandra-overview"},{"title":"The Cassandra Paper \u0026 Core Architecture","sidebarTitle":"1. Introduction \u0026 Paper","icon":"book-open","href":"/distributed-systems-tools/cassandra-paper"},{"title":"Cassandra Architecture \u0026 Storage Internals","sidebarTitle":"2. Architecture \u0026 Internals","icon":"diagram-project","href":"/distributed-systems-tools/cassandra-architecture-internals"},{"title":"Query-Driven Data Modeling in Cassandra","sidebarTitle":"3. Data Modeling","icon":"table","href":"/distributed-systems-tools/cassandra-data-modeling"},{"title":"Cassandra Read \u0026 Write Path Internals","sidebarTitle":"4. Read/Write Internals","icon":"route","href":"/distributed-systems-tools/cassandra-read-write-internals"},{"title":"Cluster Operations \u0026 Multi-DC Replication","sidebarTitle":"5. Cluster Operations","icon":"server","href":"/distributed-systems-tools/cassandra-cluster-operations"},{"title":"Performance Tuning \u0026 Production Operations","sidebarTitle":"6. Performance \u0026 Production","icon":"gauge-high","href":"/distributed-systems-tools/cassandra-performance-production"},{"title":"Capstone: Building a Real-Time Analytics Platform","sidebarTitle":"7. Capstone Project","icon":"rocket","href":"/distributed-systems-tools/cassandra-capstone"}]},{"group":"Neo4j Graph Database","icon":"diagram-project","pages":[{"title":"Neo4j Graph Database Mastery","sidebarTitle":"Overview","icon":"diagram-project","href":"/distributed-systems-tools/neo4j-overview"},{"title":"The Graph Database Story: From Theory to Neo4j","sidebarTitle":"2. Foundational Papers","icon":"scroll","href":"/distributed-systems-tools/neo4j-paper"},{"title":"Neo4j Architecture \u0026 Native Graph Storage","sidebarTitle":"3. Architecture \u0026 Storage","icon":"database","href":"/distributed-systems-tools/neo4j-architecture-storage"},{"title":"Cypher Query Language Mastery","sidebarTitle":"4. Cypher Mastery","icon":"code","href":"/distributed-systems-tools/neo4j-cypher-mastery"},{"title":"Graph Data Modeling Best Practices","sidebarTitle":"5. Data Modeling","icon":"diagram-project","href":"/distributed-systems-tools/neo4j-data-modeling"},{"title":"Graph Algorithms at Scale","sidebarTitle":"6. Graph Algorithms","icon":"diagram-project","href":"/distributed-systems-tools/neo4j-graph-algorithms"},{"title":"Production Deployment \u0026 Operations","sidebarTitle":"7. Production \u0026 Ops","icon":"server","href":"/distributed-systems-tools/neo4j-production-deployment"},{"title":"Capstone: Building a Knowledge Graph Platform","sidebarTitle":"8. Capstone Project","icon":"rocket","href":"/distributed-systems-tools/neo4j-capstone"}]}]}]}]},"basePath":"","title":"Microservices Mastery - Dev Weekends","deploymentId":"dpl_FZMKUpaaKiVETbfqhoUe4sPFDTmY","buildId":"dpl_FZMKUpaaKiVETbfqhoUe4sPFDTmY","dynamics":[],"chunks":[]}