Exactly-once claims and the reality
Why exactly-once is an application-level property, not a network guarantee.
Averho knowledge
Topics.
Every concept in the curriculum, grouped by the path it belongs to. Read them in order, or start wherever the question you have today lives.
5of 50 available now
Path 015 of 10 available
Reliable distributed workflows
Build workflows that survive retries, partial failures, and reordered messages.
0120 min read→0225 min read→0325 min read→0430 min read→0520 min read→06 07Coming soon 08Coming soon 09Coming soon 10Coming soon
Idempotency
How to make repeated operations safe in the presence of retries.
Timeouts, retries, backoff, and jitter
Bound waiting time and recover from transient failures without amplifying load.
Queues and asynchronous processing
Decouple producers from consumers to smooth load and isolate failures.
Transactional outbox
Publish events reliably by writing them in the same transaction as state.
Synchronous request-response and its limits
Where synchronous calls help and where they create fragile coupling.
Coming soon
Sagas and compensating transactions
Coordinate multi-step business processes without holding locks end-to-end.
Dead-letter queues and manual workflows
Isolate unprocessable messages and give humans a path to resolve them.
Backpressure and flow control
Let a system signal overload instead of collapsing under it.
Observability for reliability
Instrument workflows so retries, duplicates, and stalls are visible.
Path 020 of 10 available
Scaling and performance
Make systems handle more load without spending more than the load is worth.
Caching fundamentals and invalidation
What caching actually buys and why invalidation is the hard half.
Read models and materialized views
Precompute query-shaped data instead of deriving it on every request.
Indexing and query patterns
Design indexes from the queries you actually run, not from the schema.
Connection pooling and resource limits
Why a database falls over long before the application does.
Horizontal versus vertical scaling
When adding machines beats adding capacity to one machine.
Partitioning and sharding
Split data across nodes and live with the queries that no longer work.
Rate limiting and throttling
Protect shared capacity by deciding whose requests get refused.
Performance budgets and measurement
Measure latency honestly with percentiles before optimizing anything.
Asynchronous I/O and concurrency models
How threads, event loops, and async runtimes spend a machine differently.
Capacity planning and load testing
Find the breaking point deliberately instead of discovering it in production.
Path 030 of 10 available
System boundaries and integration
Design the contracts and edges where independent systems meet and evolve.
Module and service boundaries
Find the seams where a system naturally splits, before distributing anything.
API design: REST, RPC, and events
Pick an interaction style from the coupling it creates, not from fashion.
Event-driven fundamentals
Publish facts instead of commands, and accept the consequences.
Integrating external APIs
Depend on a system you do not control without inheriting its failures.
Versioning and backwards compatibility
Evolve a contract without breaking the consumers already using it.
Anti-corruption layers and adapters
Keep a foreign model from leaking into the core of your system.
Modular decomposition inside a monolith
Get boundaries and independence without paying for the network.
Monolith to microservices
Extract services incrementally and earn the cost of distribution.
Data ownership and shared databases
Why a shared database is the coupling that outlives every refactor.
Team topology and architecture
How organisation shape constrains architecture, and how to use that.
Path 040 of 10 available
Operability and production readiness
Run systems in production: observe, deploy, recover, and secure with intent.
Logging, metrics, and tracing
The three signals and the questions each one can actually answer.
Alerting and on-call fundamentals
Page a human only when a human can and must do something.
Feature flags and progressive delivery
Separate deploying code from releasing behaviour.
Configuration management
Keep configuration explicit, versioned, and separate from code.
Secrets management
Store, rotate, and scope credentials without leaking them.
Deployment strategies and rollback
Ship changes with a rollback path baked into the mechanism.
Incident response and postmortems
Coordinate during outages and learn from them blamelessly afterward.
Chaos engineering and failure injection
Probe failure modes deliberately before they surprise you.
Disaster recovery and backups
A backup you have never restored is a hypothesis, not a plan.
Security basics for backend engineers
The handful of failures that account for most real breaches.
Path 050 of 10 available
Data architecture for backend engineers
Model, store, and evolve data so it stays correct as the system grows.
Data modeling fundamentals
Model the domain's real entities, relationships, and invariants.
Normalization and denormalization
Trade write simplicity against read speed on purpose.
Transactions and isolation levels
What each isolation level prevents and the anomalies it still permits.
Event sourcing basics
Store state as an append-only log of the decisions that occurred.
Change data capture and data pipelines
Move data between systems from the log instead of from dual writes.
Data retention and archival
Decide what to keep, for how long, and where it lives afterward.
Schema evolution and migrations
Change schemas without downtime, data loss, or a big-bang cutover.
Read and write models: CQRS
Model the read and write sides separately when their needs diverge.
Consistency patterns
Strong, eventual, and causal consistency, and what each one costs.
Data quality and validation
Enforce invariants at the boundary so bad data never lands.