MSA is a decision about which criterion to use to decompose the system. Domain boundary, data ownership, scale pattern, failure isolation — the chosen criterion creates the service boundaries, and those boundaries decide communication and data in turn.
ES and CQRS address how a system’s source of truth is shaped and how its views are separated from it. Adoption cost spreads across the system, so I lean toward adopting only when the value can be stated explicitly.
Distributed transactions are about how a single ACID transaction decomposes across services and how its pieces are reassembled. The roles and trade-offs of 2PC, Saga (Choreography vs Orchestration), and Outbox.
settings.json, CLAUDE.md, slash commands, subagents, hooks. Claude Code’s customization surface settles into four layers once you pick one axis: when does each one step in?
alacritty + tmux + nvim + zsh + Claude Code in a single screen. The choices and structure behind a terminal-centric development environment.
Looking at JIRA’s issues and workflows as a graph of work units — covering the Sprint lifecycle, issue hierarchy, Git/GitHub integration patterns, and automation flows.
GitHub Actions seen as an event-driven automation engine — the three-layer abstraction of workflow / job / step, plus the operational details of triggers, runners, and secrets.
Looking at GitHub PRs as a collaboration layer on top of Git’s change graph, and walking through the Code Review cycle, PR-level design, and merge strategies.
Looking at Git as a graph of changes — and seeing how commit hygiene, branching strategy, and the merge-vs-rebase choice are all decisions about the shape of that graph.
How Security Groups (stateful, per-instance) and NACLs (stateless, per-subnet) form different layers of defense in a VPC, plus the common pitfalls each surface.
Comparing the four mechanisms that connect a VPC to other VPCs, on-premises networks, and external services — Peering, Transit Gateway, Site-to-Site VPN, and PrivateLink — across topology and cost.
How Route Tables decide traffic paths inside a VPC, the role of Internet Gateway and NAT Gateway as external exits, and the actual meaning of Public/Private Subnet.
How VPC simulates a private network boundary by combining IP CIDR, Subnet, and Tenancy. Includes vendor naming map across AWS / GCP / Azure / Alibaba.
A three-step pattern combining dual write and fallback read to transition data formats in live services without downtime.
How the CMK/DEK two-tier key structure in envelope encryption limits key leak impact and simplifies key rotation.
Which slot of the ML lifecycle each MLflow component fills, and which pieces a lightweight team can pick.
A Circuit Breaker’s trip trigger and recovery strategy must be designed together. Trip without recovery cuts the dependency permanently; recovery without a trip basis becomes meaningless cycling.
Before choosing a rate limit algorithm, the protection layer decides which algorithms are even available. This post lays out how L4/L7/Application layers and Token/Leaky/Sliding/Fixed algorithms intersect.
sklearn and ONNX aren’t competing at the same layer. Once you separate their roles, the real question becomes ‘do I need an ONNX layer at all?’
The structure and characteristics of Logistic Regression, and why an old model still serves as the baseline in CTR prediction.
Container orchestration basics and what backend developers need to know: core objects, networking, scaling with HPA, and operational essentials.
Go’s concurrency model builds on CSP, providing Goroutines and Channels as core tools. An overview of how each works and when to choose what.
Why MongoDB and Redis end up in different roles even under the same NoSQL umbrella. A comparison across data model, storage, schema, scaling, and use cases.
Spring MVC assigns one thread per request. When I/O waits pile up, threads sit idle. WebFlux replaces this with an event loop-based non-blocking model. A summary of the structural differences from MVC, the Reactor pattern, and when to choose which.
HTTP/1.1 processes requests and responses sequentially. HTTP/2 changed this with multiplexing, binary framing, and header compression. A summary of the differences between the two protocols and gRPC, which runs on top of HTTP/2.
Covers container concepts, the differences from VMs, Docker’s architecture, and the basics of Dockerfile and Docker Compose.
The difference between splitting code by technical layers (horizontal) and by features or domains (vertical). Trade-offs and selection criteria for each approach.
Nest.js provides a DI container and Module system at the framework level in the Node.js ecosystem. A summary of its core design principles: IoC, DI, Module, and Provider.
Layered architecture separates code into horizontal layers by technical responsibility. A summary of the four-layer structure, dependency direction rules, and how DIP decouples layers.
Core Kafka concepts (topics, partitions, consumer groups, replication) and the background behind KRaft mode, which removes the ZooKeeper dependency.
Core concepts of Hexagonal Architecture and its idiomatic implementation in Go using implicit interfaces and package structure for dependency direction control.
Builder is the answer when three limits of constructors meet at once — many parameters, some optional, and step-wise validation. With fewer than all three, simpler tools suffice. When the language provides rich named/default parameters, the need for Builder shrinks as well.
Factory’s shared intent is separating creation from use. The three variants — Factory Method, Abstract Factory, and Static Factory Method — split creation differently and suit different conditions. Static Factory Method is the variant most often encountered in practice, and DI containers absorb part of Factory’s explicit role.
Singleton is one of the simplest patterns but the canonical anti-pattern debate. The decision to bundle single-instance guarantee with global access into one pattern causes tight coupling and test difficulty. DI is the general alternative that separates the two intents.
DIP (principle), IoC (pattern), and DI (technique) sit at different levels of abstraction. The hierarchy must be clear before framework features and design principles can be told apart.
A pattern for switching from full cache refresh to incremental refresh. Separating data by update frequency and applying change detection reduces network costs.
What each of the four ACID properties actually guarantees in an RDB transaction. A/C/D are relatively clear guarantees, but only I has ’levels’ — the gateway to the correctness vs. concurrency trade-off.
Two transport protocols that backend developers encounter constantly. A summary of TCP and UDP — connection establishment, reliability guarantees, flow/congestion control mechanisms, and selection criteria.
HTTP is stateless. Maintaining user authentication requires storing state somewhere. This post covers the structure, trade-offs, and storage strategies of server-side sessions and client-side JWT tokens.