Advanced guides.
Under the hood: container isolation, cgroups, sandboxing untrusted code, and the architecture behind multi-tenant platforms.
75 posts · page 2 of 3
Postgres HOT Updates and Fillfactor: Cheaper UPDATEs
Every Postgres UPDATE writes a new row version — and normally new entries in every index. Heap-only tuple (HOT) updates skip the index work. When HOT applies, why indexed columns and full pages prevent it, tuning fillfactor, measuring the HOT ratio, and designing hot tables to stay HOT.
Change Data Capture in Postgres: Streaming Every Row Change
Change data capture streams every insert, update and delete out of Postgres as it happens. How logical decoding and replication slots work, publications and pgoutput, REPLICA IDENTITY, Debezium and lighter alternatives, the outbox pattern, and the operational traps — retained WAL, schema changes and failover.
PID 1 in Containers: Signals, Zombies, and Why Your Container Won't Stop
Inside a container your app is PID 1, and PID 1 is special: the kernel won't apply default signal handlers to it and it must reap orphaned children. Why docker stop takes 10 seconds, why shell-form CMD swallows SIGTERM, zombies, and the fixes: exec form, tini/--init, signal handling.
Node.js Event Loop Lag: Finding What Blocks Your Server
When one request's CPU work blocks the event loop, every other request waits. How to measure event loop delay and utilisation with perf_hooks, the usual culprits (big JSON, sync crypto, regex backtracking, sync fs), profiling with --cpu-prof, the libuv threadpool, and fixes from chunking to worker threads.
Mutual TLS (mTLS) Explained: When the Server Checks You Too
In normal TLS only the server proves its identity. With mutual TLS the client presents a certificate too. How the mTLS handshake works, running a private CA, issuing and rotating short-lived client certificates, configuring Nginx and Node, mTLS in service meshes and webhooks, and the operational traps.
Linux Pressure Stall Information (PSI): Measuring Resource Contention
CPU percentage and free memory don't tell you whether your workload is actually being slowed down. Pressure stall information does: the share of time tasks were stalled waiting for CPU, memory or I/O. Reading /proc/pressure, some vs full, per-cgroup pressure, triggers, and using PSI for alerts and OOM handling.
The Linux OOM Killer: Why Your Process Was Killed
When Linux runs out of memory it picks a process and kills it. How the kernel OOM killer chooses its victim, oom_score and oom_score_adj, cgroup v2 memory limits versus system-wide OOM, overcommit, reading the dmesg report, exit code 137 in containers, and how to stop it happening.
Linux Namespaces Explained: The Kernel Feature Containers Are Made Of
A container is a process with its own namespaces. What each of the eight Linux namespaces isolates — mount, PID, network, UTS, IPC, user, cgroup, time — how to build a container-like process by hand with unshare, inspect one with nsenter and /proc, and what namespaces do not protect against.
Linux Capabilities: Splitting Root Into Pieces
Linux capabilities break root's power into about 40 separate privileges, so a process can have just the one it needs. The capability sets (permitted, effective, inheritable, bounding, ambient), file capabilities with setcap, Docker's default set and --cap-drop ALL, why CAP_SYS_ADMIN is 'the new root', and inspecting capabilities.
Landlock: Unprivileged Sandboxing Built Into the Linux Kernel
Landlock lets an unprivileged process restrict its own filesystem and network access, permanently, for itself and its children. How rulesets, access rights and ABI versions work, a minimal C/Rust-style walkthrough, how it compares with seccomp, namespaces and AppArmor, and why coding agents use it.
Kata Containers: Container Ergonomics With VM Isolation
Kata Containers runs each pod or container inside a lightweight virtual machine with its own kernel, while keeping the OCI and Kubernetes interfaces. How the runtime, guest agent and virtio-fs fit together, hypervisor choices, the performance costs, what it protects against, and when it's worth it.
JWKS and Signing Key Rotation for JWTs
If your JWTs are signed with one secret that never changes, a single leak lasts forever. How asymmetric signing and JWKS endpoints work, the kid header, a zero-downtime rotation schedule, caching and refetch rules for verifiers, emergency revocation, and the verification mistakes that turn JWKS into an attack vector.
io_uring and Security: Why Sandboxes Turn It Off
io_uring made Linux I/O dramatically faster — and became one of the kernel's biggest sources of privilege-escalation bugs. How io_uring works, why it sidesteps seccomp filtering, which platforms disable it, the io_uring_disabled sysctl, restriction APIs, and what to do for containers and code sandboxes.
HTTP/1.1 vs HTTP/2 vs HTTP/3: What Changed and Whether You Should Care
HTTP/2 multiplexed requests over one TCP connection; HTTP/3 moved to QUIC over UDP to escape TCP's head-of-line blocking and speed up handshakes. How each works, what they fix, what they break, how browsers discover HTTP/3, and what to actually configure for your app.
How Coding Agents Work: The Loop, the Tools, and the Context Behind Them
Under the hood, Claude Code, Codex and similar agents are a model in a loop with tools and a carefully managed context. The agent loop, tools, file editing, search, context compaction, subagents, permissions and sandboxing — and what it means for you.
Firecracker Snapshots: Restoring MicroVMs in Milliseconds
Firecracker can pause a microVM, write its memory and device state to disk, and restore it later — or many times over. How the snapshot API works, full vs diff snapshots, lazy memory loading with userfaultfd, and the hard part: making clones unique (randomness, network identity, clocks) and safe.
Docker Image Layers and OverlayFS: How Container Filesystems Really Work
A Docker image is a stack of read-only layers merged by OverlayFS, with a thin writable layer per container. How layers are built and cached, content addressing and digests, copy-up and whiteouts, why deleting files doesn't shrink images, and the performance traps for databases.
DNS Rebinding Attacks: How a Website Reaches Your localhost
DNS rebinding lets a malicious web page send requests to services on your machine or private network — dev servers, admin panels, local MCP servers, routers — despite the same-origin policy. How the attack works step by step, why SSRF filters fall to it too, and the defences: Host header checks, authentication, binding, and resolve-then-pin.
Distributed Locks: Redis, Postgres and Why Fencing Tokens Matter
A lock across multiple processes or servers is harder than it looks: processes pause, leases expire and two holders can both believe they own the lock. Redis SET NX PX done right, the Redlock debate, Postgres advisory locks, fencing tokens, and when you don't need a distributed lock at all.
containerd vs Docker: How the Container Stack Fits Together
Docker Engine is built on containerd, which is built on runc — and Kubernetes now talks to containerd or CRI-O directly. What each layer does, why Kubernetes removed dockershim, namespaces in containerd, nerdctl and ctr, image stores and snapshotters, and which one you actually need.
Bubblewrap (bwrap): Building Unprivileged Sandboxes From Namespaces
Bubblewrap is the small, unprivileged sandboxing tool behind Flatpak and several AI coding agent sandboxes. How it assembles a sandbox from user, mount, PID and network namespaces, practical bwrap command lines, adding seccomp, network allow-listing via a proxy, the Ubuntu AppArmor user-namespace restriction, and its limits.
Postgres VACUUM and Table Bloat: How It Works and How to Keep It Under Control
Why Postgres tables bloat, what VACUUM and autovacuum actually do, tuning autovacuum for large tables, what blocks cleanup (long transactions, replication slots), transaction ID wraparound, and how to reclaim space without VACUUM FULL's exclusive lock.
Postgres Table Partitioning: When It Helps, When It Hurts, and How to Do It
Declarative partitioning in PostgreSQL: range, list and hash partitions, partition pruning, primary key and unique constraint rules, dropping old data instantly, automating new partitions, converting an existing table, and the cases where partitioning makes things slower.
Reading Postgres EXPLAIN ANALYZE: A Practical Guide to Query Plans
How to read a Postgres query plan: EXPLAIN vs EXPLAIN ANALYZE, BUFFERS, costs vs actual times, loops, scan and join types, spotting bad row estimates, sorts spilling to disk — plus pg_stat_statements and auto_explain for finding the queries worth fixing.