Infrastructure
What sits under an app: servers, containers, storage, backups, and the plumbing that decides whether it stays up.
139 posts · page 3 of 6
Postgres Memory Tuning: shared_buffers, work_mem and the Rest
Postgres's memory settings are conservative by default and easy to get dangerously wrong. How shared_buffers and the OS page cache work together, why work_mem is per operation not per query, maintenance_work_mem, effective_cache_size, huge pages, and worked settings for 4, 8 and 16 GB servers.
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.
"No Space Left on Device": Finding and Freeing Disk Space on a Server
When a server's disk fills up, databases stop writing, deploys fail and apps crash with ENOSPC. How to find what's using space with df and du, the usual culprits (logs, Docker, journald, old releases, deleted-but-open files), inode exhaustion, and how to stop it happening again.
Nginx Reverse Proxy Configuration: A Production-Ready Example
A complete Nginx reverse proxy config for a Node.js or Python app, explained line by line: proxy_pass, forwarding headers, WebSockets, timeouts, upload limits, HTTPS redirect, gzip, static files, multiple apps by domain, and how to test and reload safely.
Message Queues Explained: When You Need One and Which to Use
A message queue lets one part of your system hand work to another without waiting. Queues vs pub/sub vs event streams, delivery guarantees, dead-letter queues, and an honest comparison of Postgres, Redis, RabbitMQ, SQS and Kafka for a small team.
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.
How to Kill a Process in Linux (kill, pkill, killall, and Ports)
Find a stuck or runaway process and stop it: ps and pgrep to find it, kill to stop it politely, kill -9 when it won't, pkill and killall by name, killing whatever is using a port, and why a killed app comes straight back if a process manager runs 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.
IPv4 vs IPv6: What's the Difference and Does It Matter for Your App?
IPv4 addresses look like 203.0.113.7; IPv6 addresses look like 2001:db8::1. Why the internet ran out of IPv4, what IPv6 changes, A vs AAAA DNS records, and the practical things app builders need to check — like listening on both and firewalls.
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.
Hetzner vs DigitalOcean: Which Cloud Server Should You Pick?
Hetzner is known for very low prices on powerful servers, mostly in Europe; DigitalOcean for simplicity, documentation and managed services worldwide. How they compare on price, regions, managed databases, support and ecosystem, and which fits a small app.
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.
fail2ban: Automatically Ban IPs That Attack Your Server
fail2ban watches your logs for repeated failed logins and other abuse, then bans the offending IPs with the firewall. Install and configure jail.local, protect SSH and Nginx, check and unban IPs, write a simple custom filter, and know what fail2ban does and doesn't protect against.
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.
Docker Compose Networking: How Containers Talk to Each Other
How services in a Compose project find each other by name, why localhost doesn't work between containers, ports vs expose, custom and external networks, reaching the host from a container, connecting two Compose projects, and the security gotcha of published ports.
How to Deploy a Node.js App to a VPS, Step by Step
From an empty Ubuntu server to your Node.js app running on your own domain with HTTPS: create a user, install Node, clone and build, keep it running with PM2 or systemd, put Caddy or Nginx in front, and set up redeploys.
How to Deploy a FastAPI App to Production
Running uvicorn main:app --reload is for development. A production FastAPI deploy needs worker processes, a process manager or container, a reverse proxy with HTTPS, proper settings, migrations, and health checks. Step-by-step options for a VPS and Docker.
Coolify vs Dokploy: Self-Hosted PaaS Compared
Coolify and Dokploy turn your own VPS into a Heroku- or Vercel-like platform: push to Git, get a deploy with HTTPS, databases and backups. How they compare on features, architecture, multi-server support and maturity — and what you still have to look after yourself.
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.
Cloudflare Tunnel Explained: Put a Local App Online Without Opening Ports
Cloudflare Tunnel connects an app on your laptop, home server or private network to the internet through Cloudflare, with no public IP or open firewall ports. Quick tunnels for testing, named tunnels with your own domain, Access for protection, and when to use it instead of a server.
Certbot and Let's Encrypt: Free HTTPS for Nginx, Step by Step
Get a free HTTPS certificate from Let's Encrypt with Certbot and Nginx: install, issue for several domains, automatic renewal and how to test it, wildcard certificates with DNS challenges, rate limits, shorter certificate lifetimes, and fixing common Certbot errors.
BullMQ Tutorial: Background Jobs in Node.js With Redis
BullMQ is the most popular Redis-backed job queue for Node.js. Set up a queue and worker, retries with exponential backoff, delayed and repeatable jobs, concurrency and rate limiting, idempotency, graceful shutdown, monitoring, and when a Postgres queue is enough instead.