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.
GuideTechnology
15 min read
Why a query over millions of rows can take seconds or milliseconds depending on one index. Learn how B-tree indexes work, why they stay shallow, composite index column order, covering and partial indexes, selectivity, reading a query plan at a high level, why indexes are sometimes ignored, and what every index costs on writes.
GuideTechnology
17 min read
How to model data for a system design: tables, primary and foreign keys, constraints, one-to-many and many-to-many relationships, normalisation and deliberate denormalisation, ACID transactions, choosing id formats, and designing the model around access patterns. Also covers connection pooling, the N+1 problem and safe schema changes.
GuideTechnology
18 min read
Why queues exist and how they work: producers, consumers and brokers, acknowledgements and redelivery, visibility timeouts, retries, dead-letter queues, ordering, and delivery guarantees. Compares work queues, pub/sub and event streams such as Kafka, and shows how to design background workers that are safe to run twice.
GuideTechnology
17 min read
How large files are stored and delivered: object storage concepts (buckets, keys, durability, consistency, lifecycle), direct uploads with presigned URLs and multipart upload, and CDNs (edge caching, cache keys, TTLs, invalidation versus versioned URLs, static versus dynamic content, private content). Includes a compact file-storage-and-sharing design.
GuideTechnology
20 min read
Caching as a design decision: where caches live, hit ratios, cache-aside, read-through, write-through and write-back, TTLs and invalidation, LRU and other eviction policies, cache stampedes, hot keys, negative caching and distributed caches such as Redis, with the trade-off between faster reads, stale data and invalidation complexity.
GuideTechnology
18 min read
Why load balancers exist, how they spread traffic across servers, and what makes that possible: stateless services. Covers Layer 4 versus Layer 7, reverse proxies, round robin, weighted, least connections and hashing, health checks, draining, sticky sessions, redundancy of the load balancer itself, and autoscaling.
GuideTechnology
15 min read
Turn request rates into the numbers that shape an architecture: storage per day and per year with replication and retention, ingress and egress bandwidth in Gbps, cache memory from the working set, database write limits, and a first server count with headroom and zone failure. Includes a full worked example and a calculator.
GuideTechnology
16 min read
Capacity estimation from absolute basics: units and powers of two, seconds in a day, and the funnel from total users to MAU, DAU, requests per day, average QPS and peak QPS. Includes peak factors you can derive, read and write splits, fan-out, three worked examples and a small calculator.
GuideTechnology
17 min read
When should a caller wait for an answer, and when should work happen later? Learn the costs and benefits of synchronous calls and asynchronous processing, the patterns for returning results later (202 and status polling, webhooks, push), and how to choose between short polling, long polling, Server-Sent Events, WebSockets and mobile push.
GuideTechnology
19 min read
Design APIs that clients can rely on: resources and URLs, HTTP methods and which are safe to retry, status codes, validation, error formats, cursor pagination, filtering, idempotency keys, rate-limit responses, versioning, and when gRPC or GraphQL fit better than REST.
GuideTechnology
17 min read
Follow one request from a phone to a database and back: DNS lookup, TCP and TLS handshakes, HTTP, the edge, the load balancer, the application and the data stores. Learn where the time goes, why round trips and distance dominate latency, and where requests fail.
GuideTechnology
19 min read
How to turn a vague prompt such as "design a photo app" into requirements you can design for: functional requirements, clarifying questions, and non-functional requirements stated as numbers, including latency percentiles, throughput, availability nines, durability and consistency.
GuideTechnology
18 min read
What system design actually is, why interviews test it, the components you will meet and the problem each one solves, and the seven-phase method this 45-article course uses for every design, from a first single-server app to large distributed systems.
CourseTechnology
45 lessons · 12 h
A free, 45-article course that takes you from basic web and backend ideas to designing and defending real systems in SDE-1 and SDE-2 interviews. It teaches a repeatable method (requirements, estimation, APIs, data, baseline, scaling, hardening), the building blocks and distributed-systems fundamentals behind it, and 15 progressively harder case studies.
GuideTechnology
13 min read
A realistic 30-day plan to put this course into practice with free tools and 30 to 45 minutes a day, followed by a long-term roadmap that builds durable skills such as verification, workflow design and evaluation, and a way to keep up as AI changes without chasing every announcement.
GuideTechnology
13 min read
Fourteen compact, tool-independent recipe cards you can copy into your playbook: study, developer, career, research, productivity and automation. Each card gives the goal, the steps, a prompt template, the checks and the risk level, and links back to the article that explains why it works.
GuideTechnology
10 min read
By now you have habits, prompts and rules scattered across a course. This article turns them into one personal AI operating system: your principles, privacy boundaries, verification rules, tool-selection criteria, a playbook of reusable workflows and a review routine, captured in a one-page manual you can keep and update. No paid tools required.
GuideTechnology
12 min read
Agents and AI workflows fail in predictable ways: wrong tools, compounding errors, endless loops, confident 'done' messages that are not true and hostile content. This article lists the failure modes, then shows how to design for reliability with validation, escalation, approval gates, evaluation sets and staged rollout, including a runnable approval-gate example.
GuideTechnology
11 min read
How can a language model that only produces text check a calendar, search a database or edit a file? Through tool calling: the model asks, your program acts. This article explains function calling, the Model Context Protocol and the agent loop, with a runnable toy loop that shows allowed tools, step limits and what the model never does itself.
GuideTechnology
10 min read
Chatbot, workflow, automation, AI-assisted workflow and agent are often used as if they mean the same thing. They differ in who decides the next step, and that difference drives reliability, cost and risk. This article defines each, compares them on one task and gives a decision method built on one rule: use the simplest system that reliably works.
GuideTechnology
12 min read
Responsible AI use is more than accuracy and privacy. This article explains where AI bias comes from and how to test for it, the main copyright and attribution questions for what you put in and what you publish, why disclosure matters and what human judgment and accountability mean in practice.
