Core Engineering Definitions
Reliability
The probability that a system will continuously operate without failure over a specific time interval, handling errors gracefully and maintaining strict data integrity.
Availability
The proportion of time a system is in a functioning, accessible state, typically expressed as a percentage of total operational time (e.g., 99.999% uptime). It answers: Is the service up right now?
Scalability
The capability of a system to handle growing amounts of work by adding horizontal or vertical resources to the system without dropping performance.
Maintainability
How easily developers can modify, debug, test, and update the system over its software lifecycle.
Fault Tolerance
The property that enables a system to continue operating properly in the event of hardware or software failure across some of its components.
Pillar 1: Reliability & Availability Cards
Focus: Keeping the system up, handling failures, and ensuring data survival.
Consistency vs Availability (CAP Theorem)
Choosing whether a database halts and rejects updates during a network partition (Consistency) or stays online and accepts requests, risking state divergence (Availability).
Strong vs Eventual Consistency
Forcing all database replicas to sync instantly before returning a write (slow writes, perfectly synced) versus updating replicas in the background (fast writes, temporary stale reads).
Two-Phase Commit (2PC) vs Saga Pattern
Locking distributed resources tightly across microservices using a coordinator (safe, blocks traffic) versus executing local transactions sequentially with compensating rollbacks (high availability, eventual consistency).
Circuit Breakers vs Exponential Backoff
Failing fast when downstream dependencies crash to protect thread pools (Circuit Breakers) versus hammering retries with randomized delays (Backoff).
Active-Active vs Active-Passive DR
Running hot multi-region clusters with zero-downtime failover (high cost and replication complexity) versus idling a secondary standby infrastructure (incurs downtime on trigger).
Pillar 2: Performance Efficiency Cards
Focus: Latency, throughput, and scaling compute/data paths.
Latency vs Throughput
Optimizing single-request processing speed—Low Latency—versus batching operations to maximize overall payload volume per second—High Throughput.
Median (p50) vs Tail Latency (p99)
Tuning for the average user experience (p50 median) versus hunting down garbage collection stalls that affect the worst 1% of requests (p99 tail latency).
Thread-Per-Request vs Event-Loop Models
Allocating dedicated OS threads per socket connection (easy programming model, limited by RAM) versus using non-blocking asynchronous event loops (massive scale, strict zero-blocking rule).
Range-Based vs Hash-Based Sharding
Clustering sequential database keys together (efficient for ranges, creates write hotspots) versus uniformly scattering keys via hashing (balanced load, destroys range scan capability).
Long Polling vs WebSockets vs SSE
Choosing between high-overhead HTTP polling, full-duplex persistent bidirectional streams (WebSockets), or lightweight one-way server-to-client event streaming (SSE).
Pillar 3: Data Management & Storage Cards
Focus: Structuring, querying, caching, and organizing data.
SQL vs NoSQL
Using strict relational tables with ACID guarantees (complex joins, harder to scale out) versus flexible JSON documents that scale effortlessly (no standard queries).
Normalization vs Denormalization
Breaking data into clean separate tables with zero duplication (prevents update anomalies, expensive JOINs) versus duplicating data across tables (blazing fast reads, complex sync code).
Indexes vs Write Performance
Creating shortcut lookup maps to make read searches instantaneous (indexes) at the direct expense of insert and update speed (write throughput destruction).
B-Trees vs LSM-Trees
Using B-Trees to optimize random read lookups (disk fragmentation during writes) versus using LSM-Trees to append write logs sequentially (requires heavy background compaction).
Cache-Aside vs Write-Through vs Write-Back
Deciding whether application code checks cache manually and populates it on misses (Cache-Aside), updates cache and database simultaneously (Write-Through), or writes to memory first and flushes to disk later in the background (Write-Back risk of data loss).
Pillar 4: Cost & Operational Architecture Cards
Focus: Cloud budgets, deployment styles, and maintainability.
Serverless vs Containerized Compute
Using Functions-as-a-Service that scale to zero when idle (avoids waste, introduces cold starts) versus running dedicated container instances on ECS/EKS (predictable baseline cost).
Pre-computation vs On-the-Fly Processing
Materializing heavy analytical views ahead of time (instant reads, massive storage overhead) versus computing results dynamically (saves storage, spikes CPU usage).
Monolith vs Microservices
Centralizing business logic into a single deployment artifact (simple initial velocity, scaling bottlenecks later) versus breaking apart decoupled services (distributed network debugging overhead).
Stateless vs Stateful Design
Keeping zero user session state on local application servers (seamless horizontal scaling) versus caching session state locally in memory (low latency, complicates migrations).
Synchronous vs Asynchronous Workflows
Using direct blocking REST communication (tight service coupling) versus decoupling via message brokers like Kafka (buffers traffic spikes, requires handling out-of-order events).