BEGINNER · 8 MODULES · 64 LESSONS

Event-Driven Architecture

Turn a fragile chain of direct calls into an event-driven system, where one service going down doesn't stop the rest and duplicates do no harm.

For you if
You have a backend process where one failed call takes down the whole flow.
By the end
You'll know how to consume events idempotently, publish them with an outbox, and when event sourcing, CQRS, and sagas pay off.
You need
Basic Python and a working grasp of databases and transactions. No messaging experience needed.
  1. 01De la llamada al evento8 LESSONS
    1. Module introduction: from the checkout that falls over to the event that holds up
    2. The synchronous checkout is fragile
    3. Event versus command
    4. The event as an immutable fact
    5. Publish and subscribe
    6. Temporal decoupling
    7. From synchronous to event-driven
    8. Mini-project: make Mercado's checkout event-driven
  2. 02El broker y la entrega8 LESSONS
    1. Module introduction: opening the broker's box
    2. What is a broker
    3. Queue vs topic
    4. The offset and consumer groups
    5. Delivery guarantees
    6. ack/nack and re-delivery
    7. The dead-letter queue
    8. Project: build a broker that delivers and has a DLQ
  3. 03Consumidores idempotentes y orden8 LESSONS
    1. Module introduction: the debt of at-least-once
    2. What is an idempotent consumer
    3. Deduplicate by event_id
    4. Atomic dedup and natural idempotency
    5. Why ordering is not guaranteed
    6. The partition key
    7. Handling out-of-order events
    8. Project: build an idempotent, ordered consumer
  4. 04El patrón outbox8 LESSONS
    1. Module introduction: the last gap, publishing without losing
    2. The dual-write problem
    3. Why reordering and 2PC are not the answer
    4. The transactional outbox
    5. The relay
    6. Transactional outbox vs CDC
    7. Operating the outbox in production
    8. Project: reliable publishing for Mercado's `orders`
  5. 05Event sourcing8 LESSONS
    1. Module introduction: store the facts, not the result
    2. Store the events, not the state
    3. The `Order` as the sum of its events
    4. Rebuilding state by replay
    5. The log as source of truth
    6. Snapshots
    7. When to use event sourcing (and when it's over-engineering)
    8. Project: convert Mercado's `Order` to event sourcing
  6. 06CQRS (separar la escritura de la lectura)8 LESSONS
    1. Module introduction: separating what writes from what reads
    2. Command and query: two operations, two models
    3. The projection and the read model
    4. Eventual consistency: the read model lags behind
    5. One log, many read models
    6. Read only from the read model (and rebuild it)
    7. When to use CQRS (and when it's overkill)
    8. Project: split Mercado's order flow into writing and reading
  7. 07Sagas — transacciones distribuidas8 LESSONS
    1. Module introduction: the transaction that crosses services
    2. The cross-service transaction problem
    3. Why not two-phase commit
    4. The saga and compensating actions
    5. Choreography versus orchestration
    6. The lost isolation of sagas
    7. Compensatable, pivot and retriable
    8. Project: a saga for Mercado's checkout
  8. 08Proyecto — vuelve dirigido por eventos el flujo de pedidos de Mercado8 LESSONS
    1. Module introduction: the return journey, with the complete system running
    2. Modeling the order events
    3. Publishing the order events with the outbox
    4. Idempotent, decoupled consumers
    5. The checkout saga with compensation
    6. Measuring synchronous versus event-driven
    7. The architecture decision record
    8. Project: make Mercado's order flow event-driven
Reviews

What students say

These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.

No approved reviews yet.

Be the first to share your experience!

SEC. 06 · THE STUDIO

Why this studio exists

For decades, building software belonged to technical profiles with years of training, and getting a digital product into the real world took companies months or years. No-code and AI have narrowed that gap, but the knowledge is still held by a few.

Tech Benders exists to open that knowledge up, so business teams and non-technical teams can put their ideas into production with the right technical decisions behind them. AI does what you ask of it. Without a technical base, what it builds may not scale with your company’s ecosystem, and its costs can run away over time.

The team knows the pains of large organizations and the speed at which they have to move. It brings solution architecture, data engineering, product built end to end from back end to front end, and daily work with AI. Software that solves what you need in days, not months, with the cost of AI kept in check.

Founders

The studioRead about Tech Benders →

Write to ushi@techbenders.io

Made with Wislab