Systems Design & Architecture

Multi-Paxos vs Strong-Sync Primary/Replica vs Raft: Which HA Model Actually Gets You RPO=0 in 2026?

The Illusion of Scale, Part 1: When Your "Scalable" System Isn't

A Scheduler is the hidden commander of a reactivity system. It decides not whether something should run, but when it should run. New article: Building a Signal Scheduler

#38 Known is a Drop! LinkedList implementing List interface

Parts in transit - Why most distributed systems are prematurely complex

Feature Based Clean Architecture. Part 5: Scaling FBCA and a Graph-Theoretic Analysis of Dependencies

Configuration Is Not Secondary. It Is the System.

Why Developers Should Learn Systems Thinking, Not Just Programming Languages

Domain-Driven Design and Event Sourcing in .NET: Understanding the patterns, one problem at a time.

Evolução das Arquiteturas Distribuídas: O Despertar dos Sistemas Autopoiéticos e a Ascensão da Full Agentic Stack

Understanding Object-Oriented Programming in JavaScript

Roofline Model: Why Your Kernel Is Slow, Geometrically

Reactive Programming Doesn't Need a Framework — Ownership Is Enough

¿Por qué Go mató a la herencia?

Optimizing Systems Architecture: When to use Arrays vs LInked Lists

Beyond "Up" or "Down": Engineering Graceful Degradation in Go

Reference Architectures Are Lying to You

RSC Is Not the Input Boundary

Scaling Systems: Bigger Machine or More Machines?

Designing public vs. private state: what goes where and why

O que é ACID?

System Architecture is a Bit About Paranoia

AI does not only generate code faster. It changes the distribution of future changes. This post introduces Attractor Engineering: designing where software changes tend to converge.

📢Angular’s 7‑Layer Component Architecture 🗂️

GPS and GNSS in embedded systems: modules, NMEA and accuracy

How DNS Resolution Works: From `dig . NS` to Your Browser Loading Google

Designing a Content Delivery Network (CDN) Simulator

What Building a Home Server Actually Taught Me About Infrastructure

React to Rust, no try/catch

Prisma relationships, finally explained (with MySQL side by side)

Designing Good MCP Tools (This Is Where Most Systems Fail)

Eventual Consistency: Debugging the Hardest Class of Bugs

Why Incident Command Principles Should Guide Software Architecture

Building GNOME Apps with Rust, Part 4: Blueprint

Global State in Go: 5 Kinds We Found, 3 We Eliminated, 2 We Kept

Astro 4 and React Server Components: The Unexpected benchmark for Security

Building a 2D guillotine cutting optimizer for sheet goods on Capacitor + React

The Definitive Guide to misunderstood in Rust vs Monoliths: What You Need to Know

What LeetCode Optimizes For vs What Actual Production Systems Demand

Forensic Engineering: Decoding the 37-Gear Architecture of a 2,000-Year-Old Computer

Opaque Types Without `unique symbol`: A Lighter Branded-Types Pattern

`infer` in Conditional Types: 5 Recipes That Aren't in the Handbook

sync.OnceFunc, OnceValue, OnceValues: When Each Beats sync.Once

context.WithoutCancel: When You Need Work That Outlives Its Caller

The Local Eye (Sovereign Vision)

FULL STACK -DAY 1

Event-Driven Architecture: When the Complexity Pays Off

Most Startups Don’t Have a Coding Problem — They Have a Systems Problem