Cursos en esta ruta
System Design Fundamentals
Learn to design a distributed system from scratch and scale it with judgment, not memorized answers. This guide teaches the complete method — clarifying requirements, estimating capacity with back-of-the-envelope math, modeling data, adding caching, scaling the database, balancing load, and reasoning through reliability and consistency tradeoffs — using a single real case study from start to finish: Enlace, a URL shortener that starts as a single box and scales module by module into a full distributed design. Every number that appears is calculated and executed in Python (QPS, storage, hit ratio, consistent hashing), never quoted from memory. By the end, you can take a vague prompt like "design a URL shortener" and produce a defensible design with numbers, a diagram, and explicit tradeoffs — exactly what's expected in an architecture review or a system design technical interview.
64 lecciones
System Design & Scaling Guide
Master architectural thinking for AI systems: scaling strategies, reliability patterns, integration patterns (webhooks, event-driven, MCP), real-world channels (Slack/Discord), and performance vs cost trade-offs. This synthesis guide connects everything you've learned—Docker, CI/CD, deployment, monitoring, cost optimization, security—and teaches you to DESIGN production-ready systems. Culminates with the complete architecture design for the Capstone: AI-Powered Knowledge Assistant with Agentic RAG and Slack/Discord integration.
64 lecciones
Api Design And Integration
Learn to design the contract that lets one system talk to others: model resources, choose the right verbs and status codes, design requests and responses (pagination, filtering, errors), and — the core of this guide — version and evolve an API without breaking the clients that already depend on it. Everything is built on a single case study from start to finish: the public Catalog and Orders API of Mercado, a marketplace with real endpoints (`GET /v1/products`, `POST /v1/orders`) that get built and tested in Python. You'll design cursor-based pagination that actually runs, idempotency with `Idempotency-Key`, an error contract in `problem+json` format (RFC 9457), JSON Schema validation, and prove with a test how an additive change doesn't break an old consumer while a breaking change does. The guide closes with the judgment to know when REST isn't the answer and gRPC or GraphQL fit better.
64 lecciones
Architectural Styles And Boundaries
Learn to structure a system from the inside: how to split it into parts, where to draw the boundaries, and which style — monolith, modular monolith, microservices — fits which context. The guide's core is coupling and cohesion, and lightweight Domain-Driven Design bounded contexts: group what changes together, separate what changes for different reasons. You work through a single case study from start to finish: Mercado, a marketplace that started as a boundary-less monolith where everything touches everything (a change in Reviews breaks Checkout), which you'll restructure by drawing its five bounded contexts (Catalog, Orders, Payments, Shipping, Reviews). Every coupling metric — fan-in/fan-out, instability, blast radius, cycle detection — is calculated and executed in Python over a real dependency graph, never quoted from memory. The guide closes with a capstone that restructures Mercado's whole monolith: a context map, a justified style decision, and metrics measured before and after.
64 lecciones
Event Driven Architecture
Learn to build systems that communicate through events instead of direct calls: when an event beats a synchronous call, how a broker works, how to consume events idempotently, how to publish them reliably with the outbox pattern, and the bigger patterns they unlock — event sourcing, CQRS, sagas. You work through a single case study from start to finish: Mercado, whose checkout today is a fragile chain of synchronous calls (if `notifications` goes down, the order fails), which you'll turn into an event-driven flow where `orders` emits `OrderPlaced` and several services react in a decoupled way. Everything is simulated and executed in Python with an in-memory broker: you'll measure how at-least-once delivery produces duplicates and how an idempotent consumer neutralizes them, simulate a crash that exposes the dual-write problem and see how the outbox fixes it, rebuild an `Order`'s state by replaying its event log, and run a saga with compensation. By the end you know exactly what an event-driven system gains and what it costs compared to a synchronous one.
64 lecciones
Deployment & System Design Guide
Take your Python API from localhost to production on real cloud platforms (Render, Railway, Fly.io), set up managed databases (Supabase, Neon), Redis in the cloud (Upstash), a reverse proxy with Nginx, and master the fundamentals of System Design: monolith vs microservices, caching layers, message queues, scaling strategies, and API versioning. Guide #15 and the LAST one in the Backend Python Developer with FastAPI Path — the capstone that closes out the whole path.
74 lecciones
Resilience And Reliability Patterns
Learn to make a distributed system survive the failure of its parts: timeouts, retries with backoff and jitter, idempotency, circuit breakers, bulkheads, graceful degradation, and load shedding. The guide's core is partial failure — in a distributed system something is always down or slow — and how to stop a dependency's failure from taking down the whole system. You work through a single case study from start to finish: Mercado's checkout flow, where `orders` calls `payments` and `shipping`, and those dependencies genuinely fail and slow down. Everything is simulated and measured in Python with configurable failure rates and latency: you'll measure thread exhaustion without a timeout, a retry storm without backoff, how many calls a circuit breaker saves when a service is dead, how a bulkhead isolates a slow dependency so it doesn't drain the others, and the checkout's success rate before and after hardening it. The capstone combines every pattern over Mercado's full checkout flow and measures the result.
64 lecciones
Architecture For Ai Native Systems
Learn to design systems where an AI component (an LLM) is a first-class piece, and what changes in the architecture when that piece is non-deterministic, slow, expensive, and fails in new ways. The guide's core is that an LLM is not a normal function — you can't assert its exact output, it takes hundreds of milliseconds, it costs money per call, it hallucinates, and reading user data turns it into a trust boundary — and that the architecture must contain that non-determinism with a deterministic shell: evals as a quality gate, guardrails at the boundary, latency and cost budgets, fallback when the model goes down, and a data loop that improves the system over time. You work through Mercado, which adds semantic search, a support agent, recommendations, and a product-description generator for sellers. Everything is simulated and executed in Python with the LLM represented by a deterministic stub (no real API calls): you'll measure the savings of a cheap-first model cascade, run an eval-set that catches a regression, reject an invalid output at a guardrail, watch a fallback keep the system up when the model goes down, and block a model proposal that violates policy before it touches money or state. The capstone architects a complete AI feature inside Mercado.
64 lecciones
Architecture Decisions And Tradeoffs
Learn the craft of deciding in architecture: how to make decisions under uncertainty, make trade-offs explicit, record them in Architecture Decision Records (ADRs), and defend them with evidence instead of opinion. The core idea of this guide is that architecture isn't a diagram, it's a set of decisions — each with a cost, a reversibility, and consequences — and that "there's no best, only trade-offs" between quality attributes. You build a decision matrix with weighted criteria and sensitivity analysis, write ADRs in Nygard format (Context/Decision/Consequences/Status), generate and test alternatives with spikes before committing, and protect each decision with a fitness function that fails automatically if the system crosses a threshold. You also work through the cost and reversibility of deciding: one-way vs two-way doors, the last responsible moment, and technical debt as a deliberate trade-off. Everything quantifiable is executed in Python, not eyeballed. You work on Mercado's open decisions — should orders and shipping communicate synchronously or through events? should the catalog be extracted into its own service? — and close with a project where you make and record a real architectural decision end to end.
64 lecciones
Legacy Modernization And Migration
Learn to modernize a legacy system without rewriting it from scratch: the big rewrite almost always fails, and the path that actually works is incremental, measured, and reversible. This guide teaches you to put scary legacy code under a safety net with characterization tests, to divert traffic from the old system to the new one with the strangler fig pattern, and to migrate an implementation internally with branch by abstraction when there's no way to insert an external proxy. It covers extracting a bounded context from the monolith into a service with an anti-corruption layer, migrating data without turning the system off (dual-write, backfill, parallel-run), and measuring whether a migration is progressing and when it's actually done — so you avoid the endless migration that never turns the old system off. Everything is simulated and executed in Python: the monolith, the router, and the in-memory database. You work on Mercado, a legacy marketplace with catalog, orders, payments, and shipping living in a single untested monolith. It closes with a capstone project where you modernize a full slice of Mercado end to end, without turning off the business.
64 lecciones
Ai Code Governance And Agent Architecture
Learn to govern the code AI writes and to architect the systems where agents modify software autonomously. When AI generates a huge fraction of the code and some agents can change code and infrastructure without direct supervision, speed without governance produces architectural drift and an enormous blast radius. This guide teaches you to build fitness functions that block any change — human or agent — that violates architecture rules in CI, to design a least-privilege permission model that limits what each agent can touch, and to route changes by risk tier with human-in-the-loop gates: trivial changes go through automatically, while changes touching payments, auth, or migrations require human approval. It covers tracking the provenance of AI-generated code for accountability and auditing, and encoding architecture as policy-as-code that an agent can't bypass, even if it tries to ignore it. Everything is simulated and executed in Python — the agent and its diffs are stubs; you never run a real agent or call an API. You work on Mercado's team, which already uses code agents to open half of its PRs, and close by designing the full governance layer for its AI contributions.
64 lecciones
The Architect Craft
Learn the human and organizational craft of being an architect: not drawing the perfect diagram from an ivory tower, but enabling teams, communicating decisions, and aligning the organization's structure with the system's. The core idea of this guide is that architecture is made by people inside an organization, and that the architect's biggest lever isn't technical, it's social. You measure Conway's Law on a real case and apply the inverse maneuver to shape teams toward the architecture you want, communicate with the C4 model (the four zoom levels of a diagram) and use the ADR as a communication piece, lead without formal authority by sustaining the conversations that hold the architecture up, and translate business goals into quality attributes to explain the trade-off to a non-technical stakeholder. You also work through designing for change without falling into over-engineering, and documenting in a way that survives time and onboarding. What's quantifiable — communication paths, bus factor, team-module coupling — is executed in Python, not asserted from memory. You work on Mercado and its five-squad organization, and close by acting as its architect for a real business change.
64 lecciones
Working with Coding Agents
Learn to direct coding agents as a professional craft, not improvisation. This guide covers the six pieces that separate amateur use from professional use: the craft of directing instead of writing code directly, spec-driven development, harness engineering — the environment, context, and permissions you set up so the agent can verify itself — verifying and reviewing what the agent generates, budgeting and controlling token and time cost, and governing AI-generated code within a team. By the end, you can write executable specifications, prepare an agent-ready repository, review — not just accept — what an agent produces, control how much you spend in tokens and human attention, and write the playbook that governs how your team works with agents.
48 lecciones
Technical English and Employability
Learn to work and apply for jobs in English: read documentation without translating, write PRs, bug reports, and design documents in plain English, hold your own in a standup and a demo out loud, and run a job search with market judgment. The seven modules start from your actual target — the role, the market, and the English gap that separates you from it — and move through the fundamentals of reading and listening to technical English, written async communication (chat, issues, PRs, commits), writing technical documents in plain language (design docs, ADRs, READMEs, postmortems), spoken technical English (standups, meetings, pair programming, demos), your professional materials (an ATS-ready résumé, LinkedIn, portfolio), and the full hiring process. The final project is the Employability Kit: a cumulative, interview-defensible dossier with your target-role brief, a portfolio with a design doc and ADR, an async communication package, a tailored résumé, and three unscripted English recordings — a pitch, a demo, and a mock interview.
56 lecciones