Category: Software Architect

A plain-language, complete guide to throughput: what it really is, a short history of the idea from factories to fibre-optic cables to Kanban boards, how throughput is measured in networking, how it differs from bandwidth and from latency, what affects it, how it shows up in project management, how it compares to velocity, where it appears across everyday systems, real-world examples from streaming, payments and Kanban, why measuring it matters, honest trade-offs and risks, throughput in the cloud, the cost-and-performance picture, the bottleneck problem and the theory of constraints, choosing the right metric, a worked Harborline example, common pitfalls, best practices, an FAQ, and key takeaways.

A plain-language, complete guide to latency: what it really means, a short history of the idea, how latency is measured (with percentiles), how it differs from throughput and bandwidth, the four causes (propagation, transmission, processing, queuing), latency across connection types (fibre, Wi-Fi, mobile, copper, satellite), the different kinds of latency inside a system, why it matters, how human perception shapes what “fast” feels like, warning signs, real-world examples in gaming, video, trading, and browsing, engineering techniques to reduce it, honest trade-offs, best practices, common myths, an FAQ, a glossary, a “day in the life of a single tap” walkthrough, and key takeaways.

A plain-language, complete guide to the difference between latency and throughput: what each one really is, a short history of the distinction, how each is measured, what shapes them, how they interact, the surprising math of utilization and the cliff edge queueing theory predicts, the TCP vs UDP trade-off, where the trade-off shows up in real applications and real companies, why chasing only one is risky, latency and throughput in the cloud, the reliability connection, how to choose what to optimize for, a worked Chatterbox example, common pitfalls, best practices, an FAQ, and key takeaways.

A plain-language walkthrough of the classic system-design interview moment. Covers: the big idea, why interviewers love the 100x question, what 100x really means in numbers, the four flavours of growth (more users, more requests, more data, wider geography), the mindset shift from correctness to survival, a reusable five-move loop, and eight concrete steps — getting real numbers, finding the weakest link, scaling servers, scaling the database, adding queues and async work, using CDNs, designing for failure, and observability — plus SQL vs NoSQL, cost, a worked photo-sharing example, real company stories, common candidate mistakes, a ready-to-use checklist, a glossary, and takeaways.

A plain-language guide to capacity planning in system design: what it really is, why it matters, the different flavours of growth, the core ingredients (traffic, data, bandwidth), how to estimate traffic and peak load, storage and bandwidth, how to turn numbers into a server count, planning component by component, planning by system type, the three strategies (lag / match / lead), strategic / tactical / operational levels, elasticity and the cloud, the capacity planning cycle, metrics that matter, tools of the trade, a worked big-sale example, common pitfalls, capacity planning vs related ideas, the human side, a best-practices checklist, and a glossary.

A plain-language guide to load balancers: what they really are, why they matter, how they work step by step, the two families of algorithms (static and dynamic) with every common variant, different kinds of traffic to balance, Layer 4 vs Layer 7, types by scope, hardware vs software, health checks and failover, sticky sessions, where load balancers live in a real system, a worked online-store example, real-world use cases, load balancing in modern microservices, a short history, cost considerations with honest pros and cons, common pitfalls, load balancer vs related ideas (reverse proxy, API gateway, CDN), how to choose the right approach, a best-practices checklist, and a glossary.

A plain-language guide to the two most fundamental types of load balancing: static (round robin, weighted round robin, random, source IP hash, URL hash) and dynamic (least connections, weighted least connections, least response time, resource-based). Covers each algorithm in turn, a side-by-side comparison, real performance impact, how to choose between them, hybrid approaches, a worked example, historical context from task scheduling, other useful classifications (Layer 4 vs Layer 7, hardware vs software), real-world uses, testing habits, common mistakes, a best-practices checklist, and a glossary.

A plain-language, complete guide to back-of-the-envelope estimation: what it really is, where the name comes from, why interviewers care, the foundational numbers to keep in your back pocket, the common types of estimation, a repeatable six-step process, two fully worked examples (a photo-sharing app and a URL shortener), handy rules of thumb, how different industries lean on the skill, sanity-check anchors, honest advantages and limitations, common pitfalls, communication tips, a quick-reference cheat sheet, and an FAQ.

A gentle, thorough guide to one of the most useful ideas in software design: the box-of-clip-together-blocks vs. pre-molded-figure analogy, what inheritance really gives you (code reuse, polymorphism, specialization), what composition really is (holding and delegating), the two flavors composition/aggregation, the is-a vs has-a sentence test with the classic Penguin/FlyingBird and Rectangle/Square traps and the Liskov Substitution Principle, a side-by-side inheritance-tree-vs-composition-assembly diagram, the six ways inheritance breaks down (fragile base class / diamond / deep tangled hierarchies / white-box reuse / rigid-at-wrong-moment / hard-to-test), why composition often wins (flexibility, black-box reuse, no deep trees, mix and match, Single Responsibility Principle), a worked DeliveryVehicle example in Java (inheritance version vs. composition version with SpeedProfile and CargoProfile interfaces), a six-step refactoring recipe, six design patterns built on composition (Strategy / Decorator / Delegation / Dependency Injection / Observer / Adapter), a tour across Java, C#, Python, JavaScript, Go, and Rust, how composition changes testing with test doubles, when inheritance still makes sense, an eight-row comparison table, five common pitfalls, real-world analogies (restaurant stations, band, modular shelving, sports substitutions, smartphone), an FAQ, and a glossary.