Systems Design & Architecture

Your Recursion Is Lying to You About Stack Safety

Error Handling in Rust: Because Not Everything Goes According to Plan

Synthadoc: Routing at Scale, Quality Gates, and the Knowledge Backend Pattern

Do We Need System Design in the AI World?

Database Sharding Strategies: Partitioning, Consistent Hashing, and Real-World Patterns

What Stoicism Taught Me About Writing Clean Code

DDD is not about Code, it’s about Productivity!

Presentation: Evolution of a Backend for a Streaming Application

Idempotency in Distributed Systems That Actually Works

The Hidden Bottleneck Nobody Talks About in Engineering Projects

Frontend is UX, Backend is Security: Designing a Scalable RBAC System with React and JWT

Rust’s Borrow Checker: Reading Ownership, Lifetimes, and Borrowing Like the Compiler

Working with Maps and Merkle Trees in Compact

Designing for Partial Failure: Why 'Everything is Highly Available' Is a Myth

Flutter Dependency Inversion (programming to an interface)

Singleton Pattern

Who’s Holding The Map?

Hubs, Switches, and Routers Explained Like You're Debugging a Real Network

⚔️ Go vs Java: The Minimalist vs The Enterprise Veteran

¿Por qué las Goroutines son el "superpoder" que otros lenguajes envidian?

System Design Tradeoffs

We Spent Weeks Debating JSON vs Protobuf. The Real Problem Was 12 Bytes of Padding

Beyond Code: The Human Side of Technology Systems

Frugal Cascade: um padrão de resiliência para arquiteturas com orçamento zero

Scroll Restoration After Micro-Frontend Redirects: Double RAF + MutationObserver

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

Why Layered Architecture Breaks Down as Systems Grow

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

What Is a Queue, and Why Does Priority Matter?

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.

How I Passed the System Design Interview After Failing It 3 Times

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.

Stop Fetching Data in useEffect

Transaction Management Across Microservices

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

ArchUnit Part 2 — Enforcing DDD Boundaries Across Modules

Roofline Model: Why Your Kernel Is Slow, Geometrically

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

The Age of Self-Building Systems and the Rise of Self-Devouring Systems

¿Por qué Go mató a la herencia?

LRU Cache: Smart Memory Management in Your SPA

Optimizing Systems Architecture: When to use Arrays vs LInked Lists