GuideTechnology
19 min read
Design a rate limiter that enforces limits across many API servers: requirements, estimates, where the limiter sits, token bucket, leaky bucket, fixed window, sliding log and sliding window counter algorithms with a runnable comparison, atomic Redis implementations, local plus global hybrids, failure behaviour (fail open or fail closed), multi-region limits and response headers.
GuideTechnology
20 min read
The classic first system design problem, worked end to end with the course's method: requirements, estimates, APIs, data model, a simple baseline, short-code generation and collisions, 301 versus 302 redirects, caching a read-heavy path, expiry, analytics off the critical path, sharding, failures, abuse prevention, and the Pastebin variant with object storage.
GuideTechnology
14 min read
A practical, repeatable way to run a 45-minute system design interview: what interviewers typically evaluate, a 21-item checklist grouped into seven phases, a time plan, phrases for clarifying, estimating and stating trade-offs, how to handle hints and pushback, how SDE-1 and SDE-2 expectations differ, and a compact worked example.
GuideTechnology
16 min read
The security decisions that shape an architecture: trust boundaries and least privilege, authentication with passwords, MFA and identity providers, sessions versus tokens and JWTs, object-level authorisation, service-to-service identity, encryption in transit and at rest, secrets management, input validation and abuse prevention, SSRF, data privacy, audit logs and payment data.
GuideTechnology
14 min read
When services communicate by publishing facts instead of calling each other: commands versus events, event notification versus event-carried state transfer, designing and versioning events, ordering, replay, and the two patterns often paired with events: CQRS read models and event sourcing, with honest guidance on when each is worth its complexity.
GuideTechnology
14 min read
An honest comparison of monoliths, modular monoliths and microservices: what each gives and costs, why a modular monolith is often the best start, how to draw service boundaries and own data, synchronous versus asynchronous communication, API gateways, service discovery, service meshes, the distributed-monolith trap, and migrating with the strangler fig pattern.
GuideTechnology
14 min read
If you cannot observe a system, you cannot operate it. Learn the three signals (structured logs, metrics and distributed traces), the golden signals and RED and USE methods, percentiles and histograms, trace context propagation and OpenTelemetry, SLIs, SLOs and error-budget alerts, health checks and synthetic monitoring, and how to observe asynchronous systems without drowning in data.
GuideTechnology
14 min read
How systems survive failures of servers, availability zones and whole regions, and recover from data disasters. Covers failure domains, redundancy and failover, availability arithmetic with correlated failures, RPO and RTO, the four disaster-recovery strategies from backup-and-restore to active-active, multi-region write strategies, backups that actually restore, and safe deployments.
GuideTechnology
16 min read
How one slow dependency takes down a whole system, and the techniques that stop it: timeouts and deadlines, retry budgets, circuit breakers, bulkheads, rate limiting, load shedding, backpressure and graceful degradation, with a runnable circuit breaker and a degradation plan for a real page.
GuideTechnology
16 min read
When only one node may do something at a time: when you actually need a distributed lock and when you do not, locks for efficiency versus correctness, leases and why they need fencing tokens, Redis and database locks and their limits, leader election, and consensus (Raft, majorities, ZooKeeper and etcd) explained at interview depth.
GuideTechnology
16 min read
How to keep data consistent when one business action spans a database and a message broker, or several services. Covers the dual-write problem, the transactional outbox and change data capture, two-phase commit and why it blocks, and sagas with compensating transactions, choreography versus orchestration, pivot steps and isolation anomalies, with a runnable saga.
GuideTechnology
17 min read
Retries are necessary in distributed systems, and they create duplicates. Learn what idempotency means, where duplicates come from, how to build idempotency keys correctly, unique constraints and idempotent consumers, which errors to retry, exponential backoff with jitter, retry amplification, and what at-most-once, at-least-once and effectively-once delivery really promise.
GuideTechnology
15 min read
What "consistent" means when data is replicated, from linearizability through causal and session guarantees to eventual consistency; what the CAP theorem actually says and why "pick two" misleads; PACELC and the everyday latency trade-off; quorum reads and writes; resolving conflicts; and choosing consistency per feature instead of per system.
GuideTechnology
14 min read
What changes when work is spread over many machines: partial failure, messages that are lost, delayed, duplicated or reordered, timeouts with unknown outcomes, process pauses, and clocks that disagree. Learn why a timeout does not tell you what happened, why wall clocks cannot order events, how logical clocks help, and the design habits that follow.
GuideTechnology
15 min read
A trade-off-driven guide to choosing databases: relational, key-value, document, wide-column, graph, search, time-series and analytical stores, what each is good and bad at, query-first modelling for NoSQL, the myths ("NoSQL scales, SQL doesn't"), polyglot persistence, and a decision process you can use in interviews.
GuideTechnology
17 min read
When one database can no longer hold the data or absorb the writes, you split it. Learn vertical and horizontal partitioning, how to choose a partition key, range, hash, consistent-hashing and directory-based sharding, rebalancing with logical shards, hot partitions, cross-shard queries and secondary indexes, and why you should shard as late as possible.
GuideTechnology
15 min read
Why databases keep copies on several machines, and what those copies cost. Covers primary-replica replication, synchronous versus asynchronous replication, read replicas for scaling, replication lag and the read anomalies it causes, read-your-writes routing, failover and split brain, multi-leader and leaderless replication, and why replication is not a backup.
GuideTechnology
16 min read
What goes wrong when many requests touch the same rows at once: lost updates, double booking, write skew, dirty and non-repeatable reads. Learn isolation levels, MVCC, atomic conditional updates, row locks, optimistic concurrency with versions, constraints, deadlocks and hot rows, with a runnable simulation and worked examples.
