Skip to main content
Explore
Log in
Get started
Someone wanted to learn this too, so Grasp built them a personal learning path.
Create your own
Understand distributed systems architecture
Module 1
Foundations of Distributed Computing
1
Identifying Distributed System Characteristics in Familiar Platforms
Analyze a familiar system from your experience (e.g., Revolut's FX trading platform) to identify characteristics that make it distributed (concurrency, lack of global clock, independent failures).
Analyze a familiar system from your experience (e.g., Revolut's FX trading platform) to identify characteristics that make it distributed (concurrency, lack of global clock, independent failures).
2
The Impossibility of Synchronized Clocks for Distributed Ordering
Derive why distributed systems cannot rely on synchronized physical clocks for ordering, using logical reasoning about network delays.
Derive why distributed systems cannot rely on synchronized physical clocks for ordering, using logical reasoning about network delays.
3
Understanding Consistency Models
Define and differentiate between linearizability, sequential consistency, causal consistency, and eventual consistency, providing practical examples for each.
Define and differentiate between linearizability, sequential consistency, causal consistency, and eventual consistency, providing practical examples for each.
4
CAP and PACELC: Database Trade-offs
Analyze the trade-offs defined by the CAP theorem and its extension, the PACELC theorem, using real-world database systems as examples.
Analyze the trade-offs defined by the CAP theorem and its extension, the PACELC theorem, using real-world database systems as examples.
5
Consensus Algorithms: Paxos, Raft, and Beyond
Compare the roles and high-level mechanisms of consensus algorithms (e.g., Paxos, Raft) in providing fault-tolerance and strong consistency.
Compare the roles and high-level mechanisms of consensus algorithms (e.g., Paxos, Raft) in providing fault-tolerance and strong consistency.
6
Understanding Distributed System Failures
Define network partitions, node failures, and Byzantine failures, providing concrete examples of how each could manifest in a high-stakes financial system.
Define network partitions, node failures, and Byzantine failures, providing concrete examples of how each could manifest in a high-stakes financial system.
Module 2
Distributed Communication Patterns
7
Synchronous Request-Response with Timeout and Error Handling in Python
Implement a synchronous request-response pattern in Python for a simplified trading scenario, demonstrating robust handling of network timeouts and service unavailability.
Implement a synchronous request-response pattern in Python for a simplified trading scenario, demonstrating robust handling of network timeouts and service unavailability.
8
Asynchronous Messaging with RabbitMQ
Implement asynchronous message passing between services using a message queue (e.g., RabbitMQ) for the same trading scenario.
Implement asynchronous message passing between services using a message queue (e.g., RabbitMQ) for the same trading scenario.
9
Synchronous vs. Asynchronous Communication Trade-offs
Compare the trade-offs between synchronous and asynchronous communication patterns in terms of latency, throughput, coupling, and fault tolerance.
Compare the trade-offs between synchronous and asynchronous communication patterns in terms of latency, throughput, coupling, and fault tolerance.
10
Idempotency in Distributed Systems: Payment Processing Risks
Explain the role of idempotency in distributed systems, using examples from payment processing to illustrate the risks of non-idempotent operations.
Explain the role of idempotency in distributed systems, using examples from payment processing to illustrate the risks of non-idempotent operations.
11
Implementing Resilient Service Communication with Exponential Backoff and Jitter
Implement client-side retry logic with exponential backoff and jitter for handling transient failures in service communication.
Implement client-side retry logic with exponential backoff and jitter for handling transient failures in service communication.
12
Delivery Semantics: System-Wide Implications
Analyze the system-wide implications of at-least-once, at-most-once, and exactly-once delivery semantics.
Analyze the system-wide implications of at-least-once, at-most-once, and exactly-once delivery semantics.
Module 3
Asynchronous Messaging with Message Brokers
13
Running RabbitMQ Locally with Docker
Install and run a RabbitMQ instance locally using Docker.
Install and run a RabbitMQ instance locally using Docker.
14
Implementing Pub/Sub with RabbitMQ in Python
Programmatically declare a RabbitMQ exchange and queue, and bind them to implement a pub/sub pattern using a Python client library.
Programmatically declare a RabbitMQ exchange and queue, and bind them to implement a pub/sub pattern using a Python client library.
15
RabbitMQ Pub/Sub in Python
Implement publishers and subscribers in Python that communicate via the configured RabbitMQ topology.
Implement publishers and subscribers in Python that communicate via the configured RabbitMQ topology.
16
RabbitMQ Competing Consumers for Parallel Processing
Configure the competing consumers pattern in RabbitMQ to enable parallel processing of messages from a single queue.
Configure the competing consumers pattern in RabbitMQ to enable parallel processing of messages from a single queue.
17
Implementing a Dead-Letter Queue (DLQ)
Implement a dead-letter queue (DLQ) mechanism to handle message processing failures gracefully.
Implement a dead-letter queue (DLQ) mechanism to handle message processing failures gracefully.
18
Queue vs. Log: Message Broker Trade-offs
Explain the architectural trade-offs between queue-based (e.g., RabbitMQ) and log-based (e.g., Kafka) message brokers.
Explain the architectural trade-offs between queue-based (e.g., RabbitMQ) and log-based (e.g., Kafka) message brokers.
19
Monitoring and Troubleshooting Message Brokers
Identify key metrics for monitoring message broker performance (e.g., queue depth, consumer lag) and diagnose common bottlenecks.
Identify key metrics for monitoring message broker performance (e.g., queue depth, consumer lag) and diagnose common bottlenecks.
Module 4
Designing Event-Driven Architectures
20
Events, Commands, and Queries in Event-Driven Systems
Differentiate between domain events, commands, and queries in the context of event-driven systems.
Failed
Differentiate between domain events, commands, and queries in the context of event-driven systems.
21
Event Schema Design with Python Data Classes
Design event schemas using a formal definition language (e.g., JSON Schema, Protocol Buffers) and generate corresponding Python data classes.
Failed
Design event schemas using a formal definition language (e.g., JSON Schema, Protocol Buffers) and generate corresponding Python data classes.
22
Transactional Outbox with Relational Databases
Implement the transactional outbox pattern using a relational database to ensure atomic state changes and event publishing.
Failed
Implement the transactional outbox pattern using a relational database to ensure atomic state changes and event publishing.
23
Choreography vs. Orchestration: Workflow Analysis
Analyze a workflow from your domain (e.g., payment clearing) and contrast its implementation using choreography vs. orchestration patterns.
Failed
Analyze a workflow from your domain (e.g., payment clearing) and contrast its implementation using choreography vs. orchestration patterns.
24
Event Storming: Process and Key Artifacts
Describe the process and key artifacts of an event storming workshop, such as domain events, commands, aggregates, and bounded contexts.
Failed
Describe the process and key artifacts of an event storming workshop, such as domain events, commands, aggregates, and bounded contexts.
25
Event Storming for Business Process Modeling
Apply event storming principles to model a given business process and derive its corresponding event flow.
Failed
Apply event storming principles to model a given business process and derive its corresponding event flow.
26
Handling Out-of-Order Events with Sequence Numbers and Vector Clocks
Implement a consumer strategy using sequence numbers or vector clocks to detect and handle out-of-order events.
Failed
Implement a consumer strategy using sequence numbers or vector clocks to detect and handle out-of-order events.
Module 5
State Management with Event Sourcing
27
Event Sourcing: Principles and Distinctions from State-Oriented Persistence
Explain the core principles of event sourcing and how it differs from traditional state-oriented persistence.
Explain the core principles of event sourcing and how it differs from traditional state-oriented persistence.
28
Designing Aggregate Roots and Domain Events in Financial Scenarios
Design aggregate roots and domain events for a financial scenario from your experience (e.g., FX trade lifecycle).
Design aggregate roots and domain events for a financial scenario from your experience (e.g., FX trade lifecycle).
29
Event Replay for State Reconstruction
Implement event replay to reconstruct the current state of an aggregate from its historical event stream.
Implement event replay to reconstruct the current state of an aggregate from its historical event stream.
30
Optimizing Aggregate State Reconstruction with Snapshots
Implement snapshots for an aggregate to optimize state reconstruction performance for long-lived objects.
Implement snapshots for an aggregate to optimize state reconstruction performance for long-lived objects.
31
Event Schema Evolution Strategies
Explain common strategies for event schema evolution (e.g., upcasting, lazy migration) and their trade-offs.
Explain common strategies for event schema evolution (e.g., upcasting, lazy migration) and their trade-offs.
32
Python Event Upcasting for State Reconstruction
Implement an upcaster function in Python to transform an older event version into the current version during state reconstruction.
Implement an upcaster function in Python to transform an older event version into the current version during state reconstruction.
33
Event Sourcing: Pros, Cons, and Use Cases
Analyze the benefits and drawbacks of event sourcing, identifying use cases where it is and is not appropriate.
Analyze the benefits and drawbacks of event sourcing, identifying use cases where it is and is not appropriate.
Module 6
Implementing CQRS and Resilient Persistence
34
CQRS: Balancing Complexity and Benefits
Analyze the Command Query Responsibility Segregation (CQRS) pattern, explaining when its complexity is justified.
Analyze the Command Query Responsibility Segregation (CQRS) pattern, explaining when its complexity is justified.
35
Designing CQRS Models for Financial Scenarios
Design separate write (command) and read (query) models for the financial scenario modeled in the previous module.
Design separate write (command) and read (query) models for the financial scenario modeled in the previous module.
36
Building Denormalized Read Models with Event Streams
Implement a projection that consumes an event stream to build and maintain a denormalized read model.
Implement a projection that consumes an event stream to build and maintain a denormalized read model.
37
Handling Eventual Consistency and Data Staleness
Address eventual consistency between write and read models, including strategies for communicating data staleness to clients.
Address eventual consistency between write and read models, including strategies for communicating data staleness to clients.
38
Designing an Event Store API Contract
Define the API contract for a generic event store service, including methods for appending events and retrieving event streams.
Define the API contract for a generic event store service, including methods for appending events and retrieving event streams.
39
Optimistic Concurrency with Aggregate Versions
Implement optimistic concurrency control in an event store service by using aggregate version numbers to detect write conflicts.
Implement optimistic concurrency control in an event store service by using aggregate version numbers to detect write conflicts.
40
Choosing the Right Event Store: Trade-offs in Persistence Technologies
Compare the trade-offs between different persistence technologies for implementing an event store (e.g., relational DB, document DB, specialized event store).
Compare the trade-offs between different persistence technologies for implementing an event store (e.g., relational DB, document DB, specialized event store).
Module 7
Applying Event Sourcing in Python
41
Eventsourcing Library vs. Manual Implementation
Compare the Python 'eventsourcing' library with a manual implementation approach based on criteria such as developer experience, persistence options, and maintainability.
Compare the Python 'eventsourcing' library with a manual implementation approach based on criteria such as developer experience, persistence options, and maintainability.
42
Integrating Eventsourcing with a Message Broker
Set up the 'eventsourcing' library with a message broker integration for event notification.
Set up the 'eventsourcing' library with a message broker integration for event notification.
43
Implementing DDD Building Blocks
Implement aggregates, commands, and events for a sample application using the framework's abstractions.
Implement aggregates, commands, and events for a sample application using the framework's abstractions.
44
Configuring Event Storage with PostgreSQL
Configure the framework to use a separate persistence service (e.g., PostgreSQL) for event storage.
Configure the framework to use a separate persistence service (e.g., PostgreSQL) for event storage.
45
Building Projections and Read Models with Notifications
Implement projections and read models that are driven by the framework's notification system.
Implement projections and read models that are driven by the framework's notification system.
46
Testing Event-Sourced Applications
Write unit and integration tests for an event-sourced application using the framework's testing utilities.
Write unit and integration tests for an event-sourced application using the framework's testing utilities.
Module 8
Resilience and Operability in Distributed Systems
47
Health Checks and Readiness Probes for Python Services
Implement health checks and readiness probes for a distributed Python service.
Implement health checks and readiness probes for a distributed Python service.
48
Implementing Circuit Breakers with Python
Implement the circuit breaker pattern using a Python library (e.g., 'pybreaker') to prevent cascading failures between services.
Implement the circuit breaker pattern using a Python library (e.g., 'pybreaker') to prevent cascading failures between services.
49
Distributed Tracing with OpenTelemetry and Jaeger
Set up a local tracing backend (e.g., Jaeger) and instrument multiple communicating Python services using OpenTelemetry.
Set up a local tracing backend (e.g., Jaeger) and instrument multiple communicating Python services using OpenTelemetry.
50
Distributed Tracing: Pinpointing Bottlenecks and Errors
Analyze distributed traces in a UI to identify performance bottlenecks and error propagation in a multi-service workflow.
Analyze distributed traces in a UI to identify performance bottlenecks and error propagation in a multi-service workflow.
51
Idempotent Consumer with Persistent Tracking
Implement an idempotent consumer that uses a persistent layer (e.g., Redis, a database table) to track processed message IDs.
Implement an idempotent consumer that uses a persistent layer (e.g., Redis, a database table) to track processed message IDs.
52
Exactly-Once Processing with At-Least-Once Delivery and Idempotent Consumers
Explain how combining at-least-once message delivery with idempotent consumers achieves exactly-once processing semantics.
Explain how combining at-least-once message delivery with idempotent consumers achieves exactly-once processing semantics.
53
Deployment Challenges in Event-Driven Architectures
Analyze the unique challenges of blue-green and canary deployment strategies within an event-driven architecture (e.g., stateful consumers, schema evolution, message compatibility).
Analyze the unique challenges of blue-green and canary deployment strategies within an event-driven architecture (e.g., stateful consumers, schema evolution, message compatibility).