Infrastructure
What sits under an app: servers, containers, storage, backups, and the plumbing that decides whether it stays up.
139 posts · page 4 of 6
Basic Linux Commands: The 50 You Need to Manage a Server
The Linux commands that cover almost everything you'll do on a server: moving around, files and folders, reading files and logs, searching, permissions, processes, disk and memory, networking, packages and services — each with a one-line explanation.
The 3-2-1 Backup Rule for Apps and Databases
Three copies of your data, on two kinds of storage, one off-site — and the modern additions: one immutable copy and zero restore errors. What counts as a copy, applying it to a Postgres-backed app, retention, encryption, ransomware and AI-agent mistakes, and testing restores.
What Is Linux? A Beginner's Guide for People Building Apps
Linux runs most of the world's servers — including, probably, the one your app will live on. What Linux is, kernels vs distributions, Ubuntu vs Debian vs Alpine, how it differs from Windows and macOS, and the handful of Linux facts that prevent deploy bugs.
What Is Latency? Why Distance Makes Your App Feel Slow
Latency is the delay before data arrives; bandwidth is how much can arrive at once. What latency is, why physical distance sets a floor on it, why round trips multiply it, latency vs bandwidth vs throughput, and practical ways to make an app feel faster for faraway users.
What Is a VPS? Virtual Private Servers Explained for Beginners
A VPS is your own slice of a physical server, with its own operating system and full control. What a VPS is, how it compares with shared hosting, PaaS and dedicated servers, what you're responsible for when you run one, and when a managed server is the better fit.
What Is a DDoS Attack? A Plain-English Guide for Website Owners
A DDoS attack floods a website with traffic until real visitors can't get through. How DDoS attacks work, the main types, how likely a small site is to be hit, what DDoS protection actually does, and the cheap steps that protect a small app.
SSH Port Forwarding Explained: Local, Remote, and Dynamic Tunnels
SSH tunnels let you reach a database or web app on a server as if it were on localhost — without opening ports to the internet. Local (-L), remote (-R) and dynamic (-D) forwarding with practical examples, background tunnels, and the security caveats.
The SSH Config File Explained: Stop Typing Long SSH Commands
~/.ssh/config turns ssh -i ~/.ssh/key -p 2222 deploy@203.0.113.10 into ssh prod. Where the file lives on each OS, the options worth knowing, multiple GitHub accounts, jump hosts, keep-alives, and the precedence rule that trips people up.
How to Reduce Docker Image Size: From 1.5 GB to Under 200 MB
Big Docker images are slow to build, push, pull and deploy. The techniques that actually shrink them: slim base images, multi-stage builds, .dockerignore, production-only dependencies, layer ordering, cache cleanup — with Node.js and Python examples and a way to see what's taking space.
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.
PM2 vs systemd: How to Keep a Node.js App Running on a Server
When you run node app.js over SSH and log out, your app dies. How PM2 and systemd keep it running, restart it after crashes and reboots, handle logs and environment variables — with working configs for both, and where Docker fits.
Node.js vs Bun vs Deno: Which JavaScript Runtime in 2026?
Three runtimes run JavaScript outside the browser. How Node.js, Bun and Deno differ on speed, compatibility, TypeScript support, security and built-in tools — and why most apps should still start on Node.js.
Finding Memory Leaks in Node.js: Heap Snapshots, Retainers, and Common Culprits
Your Node.js server's memory climbs until it crashes. How to confirm a leak, read process.memoryUsage, capture heap snapshots in production safely, compare them in Chrome DevTools, follow retainer chains, and fix the usual causes: unbounded caches, listeners, timers and closures.
Linux File Permissions Explained: chmod 755, 644, and "Permission Denied"
What rwxr-xr-x means, how chmod numbers like 755, 644 and 600 work, chmod +x for scripts, chown, the correct permissions for SSH keys, and why chmod 777 is never the right fix for "Permission denied".
How KVM Virtualization Works: The Isolation Behind Cloud Servers
Most cloud VMs run on KVM. How hardware-assisted virtualization works — VT-x/AMD-V, the VMM, virtio, two-level page tables — what a VM boundary protects against compared with containers, the remaining risks (side channels, noisy neighbours, steal time), and what shared vs dedicated vCPUs mean.
Horizontal vs Vertical Scaling: How Apps Handle More Users
Vertical scaling means a bigger server; horizontal scaling means more servers. How each works, what load balancers do, why databases are the hard part, what has to change in your app to scale out, and why most small apps should scale up first.
Health Check Endpoints: What /health Should (and Shouldn't) Check
A health check endpoint tells load balancers, orchestrators and monitors whether your app can serve traffic. Liveness vs readiness, what to check and what not to, response formats, timeouts, security, and examples for Express, Next.js and Docker.
Graceful Shutdown in Node.js: Handling SIGTERM Without Dropping Requests
Every deploy and restart sends your Node.js app SIGTERM. How to shut down gracefully: stop accepting traffic, fail readiness, finish in-flight requests, close keep-alive connections, drain workers, close database pools — plus the Docker PID 1 and npm start signal traps.
Encryption at Rest vs in Transit: What's the Difference?
Encryption in transit protects data moving across a network; encryption at rest protects data stored on disk. What each one protects against, what it doesn't, how HTTPS, disk encryption and field-level encryption fit together, and what a small app actually needs.
Do You Need Kubernetes? (Probably Not Yet — Here's How to Tell)
Kubernetes runs containers across many machines and is everywhere in job ads. What it actually does, what it costs to operate, the signs you might need it, and the simpler options that serve almost every small app and startup better.
DNS Propagation Explained: Why Domain Changes Take Time (and How to Speed Them Up)
You changed a DNS record and your site still points to the old place. What "DNS propagation" really is (caching, not spreading), how TTL controls the wait, why nameserver changes take longest, how to check from different places, and how to flush your own cache.
Cron Expressions Explained: What "*/5 * * * *" Means (With Examples)
A beginner's guide to cron syntax: the five fields, special characters, a cheat sheet of common schedules (every 5 minutes, daily at 9am, weekdays), the time zone and overlap gotchas, and where cron expressions show up — crontab, GitHub Actions, and app schedulers.
Zero-Downtime Deploys for a Small App
You don't need Kubernetes to deploy without dropping requests. What actually causes downtime during a deploy — stopping before starting, no health checks, killed requests, and database changes the old code can't handle — and the four practices that fix each one.
Why Is My Website Slow? A Beginner's Guide to Finding Out
Slow sites lose visitors. How to measure speed properly, what Core Web Vitals mean, and the usual culprits in AI-built apps — huge images, too much JavaScript, slow database queries, waterfalls of API calls, and a server far from your users — with a fix for each.