Daily practice · No sign-up · No paywall

Practise architecture
the way it is actually asked.

Real solution-architecture and system-design interview questions with answers written the way you would have to defend them in a review, drilled with flashcards until the vocabulary is automatic, and a glossary for every term that turns up along the way.

2026-08-20

Today’s three, then you are done.

One question, one card and one term, picked from the date itself so everybody sees the same three and a reload does not reshuffle them. Come back tomorrow for the next set.

Question of the day intermediate
Networking

A user in Mumbai types your URL and presses enter. Walk me through every hop until the HTML reaches their browser. Where would you look first if the page were slow?

Show the answer Hide the answer

What the interviewer is testing

This is the classic architecture screening question, and it is asked because the answer's depth correlates strongly with real experience. There is no trick — it is a knowledge audit.

The path

1. DNS resolution. Browser cache, then OS cache, then the configured resolver. On a miss the resolver walks root → TLD → authoritative nameserver. Latency-based or geo routing at the authoritative server may return a different address for Mumbai than for London. Cost: 0 ms cached, 20–120 ms cold.

2. TCP handshake. SYN, SYN-ACK, ACK — one round trip to the nearest CDN edge. If the edge is in Mumbai, roughly 5–20 ms; if the connection goes to an origin in Virginia, 200 ms or more. This is the single biggest argument for edge termination.

3. TLS handshake. TLS 1.3 completes in one round trip; TLS 1.2 needs two. Session resumption or 0-RTT removes it for returning visitors. Certificate chain validation happens here, and OCSP stapling avoids a separate request to the CA.

4. CDN edge. On a hit, the response is served now and everything below is skipped. On a miss, the edge fetches from origin — over a pre-warmed, optimised backbone connection rather than the public internet, which is a large and often-forgotten benefit.

5. Origin load balancer. Health-checked routing to a healthy instance, possibly with a second TLS handshake if traffic is encrypted internally.

6. Reverse proxy / ingress. Path routing, rate limiting, header manipulation.

7. Application. Session lookup, authorisation, business logic.

8. Data layer. Cache lookup, then database on a miss. This is where most of the variable time lives, and where N+1 query patterns hide.

9. Response back. Compression, cache headers that determine whether the next visitor even reaches step 4.

10. Browser rendering. HTML parse, blocking CSS and JS, subresource fetches — which repeat steps 1–4 for every distinct origin, which is why third-party scripts are so expensive.

Where to look first

In this order, because it goes cheapest-diagnosis-first:

  1. Is it slow for everyone or just this region? Regional means DNS routing, edge coverage or peering. Global means origin.
  2. Is it slow for the first byte or after it? High TTFB means server-side or network; low TTFB with slow render means front-end.
  3. Cache hit ratio at the CDN. A ratio that dropped means a cache-busting change, and it is a common and easily-missed cause.
  4. Server-side traces. p99 by endpoint, then the slow span within the trace.
  5. Database. Slow query log, then connection pool saturation — a request waiting for a connection looks like a slow query but is not one.

What a strong answer adds

Naming the fixed costs that no code change removes: light takes about 60 ms round trip between Mumbai and Virginia, and the only fix is to serve from closer. Candidates who reach for physics before micro-optimisation are the ones who have debugged this before.

Card of the day intermediate
Security Architecture
Term of the day concept
Architecture Decision-Making

Synchronous vs Asynchronous Communication

The test: does this user action succeed or fail based on this callee's response? If yes, synchronous; you need the answer to decide. If no, asynchronous; waiting buys nothing and costs you the callee's availability.

Synchronous makes the caller's availability the product of every callee's — four dependencies at 99.9% cap you near 99.6% — makes latency additive including the tail, and forces the caller to handle partial failure mid-sequence.

Asynchronous decouples availability and latency, and charges eventual consistency, harder end-to-end debugging, and the need for idempotent consumers, dead letter queues and replay. It also converts "the user sees an error now" into "the user sees success and something goes wrong later", which is sometimes the worse outcome.

The option people forget sits between them: synchronous request, asynchronous completion — accept the work, return 202 Accepted with a status URL or a webhook, complete out of band. That keeps the caller's contract honest while removing the work from the critical path.

The curriculum

Eight pillars, 20 topics.

The order runs from what architecture is, through the systems it is made of, out to the economics and communication that decide whether it ever gets built.

01

Core Architecture

What architecture is, the patterns it is assembled from, and how the decisions get made.

10 questions 46 cards 54 terms
02

Distributed Systems & Data

Many machines, partial failure, and the state they all disagree about.

10 questions 39 cards 41 terms
03

Platform, Cloud & Networking

The substrate the design runs on, and the path a single request takes through it.

8 questions 24 cards 39 terms
04

Reliability & Operations

Keeping it up, knowing when it is not, and knowing what breaks first under load.

9 questions 32 cards 37 terms
05

Security & Trust

Threats, trust boundaries and the blast radius of every design choice.

3 questions 16 cards 18 terms
06

Business & Economics

Cost, capability, governance and the language executives fund architectures in.

8 questions 22 cards 32 terms
07

Modernization & AI

Systems that already exist, and the workloads that only started existing recently.

5 questions 19 cards 21 terms
08

The Architect's Craft

The reasoning habits underneath everything above.

1 questions 6 cards 8 terms