Madeactual (@Madeactual) header
Madeactual (@Madeactual) profile picture

Custom software, made workable. Operational systems, integrations, automation, and finishing projects that stalled.

Joined August 2026
Madeactual builds the operational software most shops leave unfinished. Integrations, internal tools, cutovers, and the spreadsheet that quietly became the system of record. I quote a named slice, name the owner and the exception path, and I will not rewrite your ten-year codebase in week one. Start with a free project review: madeactual.com/#quote
1
1
10
2,391
A small curl habit for when an API feels slow and nobody knows where the time goes: have curl break it down. curl -o /dev/null -s -w 'dns %{time_namelookup} connect %{time_connect} tls %{time_appconnect} first byte %{time_starttransfer} total %{time_total}\n' api.example.com/health If dns is big, look at the resolver. If connect or tls is big, it's the network or the handshake. If first byte is most of the total, the server is doing the slow work, so go look at the app and its queries.
1
1
14
A small habit before moving a site or API to a new server: lower the DNS TTL a day or two ahead. dig +noall +answer api.example.com If that record has a TTL of 86400, resolvers can keep sending people to the old box for up to a day after you switch. Drop it to 300 first, wait out the old TTL, then cut over. If something breaks, rollback takes minutes instead of a day. Raise it again once things settle. Got a migration coming up and want a second pair of hands on the cutover plan? That's work we do: madeactual.com/#quote
10
A small Postgres habit before any migration on a busy table: set a lock_timeout first. SET lock_timeout = '3s'; ALTER TABLE orders ADD COLUMN notes text; Even a quick ALTER needs a brief exclusive lock. If a long-running query is holding the table, the ALTER waits in line, and every normal read and write queues up behind it. A two-second change turns into a stalled app. With lock_timeout, the migration gives up after 3 seconds instead of freezing everything. Retry it in a quieter minute.
1
1
30
A small Postgres habit for hand-fixing data in production: wrap it in a transaction and look before you commit. BEGIN; UPDATE invoices SET status = 'void' WHERE customer_id = 4821 AND status = 'draft' RETURNING id, status; Psql prints the rows it touched, then UPDATE 3. Expected 3? COMMIT. Saw 3,000? ROLLBACK, and nothing happened. Don't leave it open while you think, though. Those rows stay locked until you finish. If you want a second set of eyes on a messy data cleanup, this is the kind of work we do: madeactual.com/#quote
17
Git trick for "when did this line disappear?": the pickaxe search. git log -S 'retry_limit' --oneline -- src/ It lists only the commits where that string was added or removed, so you jump straight to the change instead of scrolling blame through ten refactors. Add -p to see the diffs, or use -G with a regex when you need a pattern instead of an exact string. What's your go-to for digging through history?
1
1
32
A small Postgres habit for adding NOT NULL to a big table without blocking writes for minutes: add a CHECK constraint as NOT VALID, validate it, then set NOT NULL. ALTER TABLE orders ADD CONSTRAINT orders_email_nn CHECK (email IS NOT NULL) NOT VALID; ALTER TABLE orders VALIDATE CONSTRAINT orders_email_nn; ALTER TABLE orders ALTER COLUMN email SET NOT NULL; On PG12+, the last step sees the valid check and skips the full scan. Then drop the check. If you want a hand with migrations like this: madeactual.com/#quote
18
A small Git habit for review fixes on a branch: commit them as fixups, then fold them in before merge. git commit --fixup=abc123 git rebase -i --autosquash main Each fix lands in the commit it belongs to, so history reads clean and reviewers still see what changed.
2
1
64
Docker Compose tip: plain depends_on only waits for the db container to start, not for Postgres to accept connections. Add a healthcheck and wait on it: healthcheck: test: pg_isready -U app depends_on: db: condition: service_healthy Need a hand? madeactual.com/#quote
1
1
20
Dead-letter queues only help if someone notices them. A setup we've been using lately: - alert when DLQ depth stays above zero for 10 min - store the payload, last error, and attempt count with each message - keep a one-line replay command Then fix + redrive happens the same day.
8
A small Proxmox habit before any risky change on a VM: take a snapshot first. qm snapshot 104 pre-upgrade If it goes sideways: qm rollback 104 pre-upgrade. Once you're happy, qm delsnapshot it so it doesn't keep growing. Need ops help like this? madeactual.com/#quote
1
1
24
A small shell habit for batch jobs that crawl because they run one item at a time: let xargs run them in parallel. xargs -P 8 -n 1 curl -sfO < urls.txt Eight at once instead of one. Keep -P modest when the other end is someone's API, or you trade a slow job for a pile of 429s.
1
1
72
Postgres: ON CONFLICT DO NOTHING RETURNING id returns nothing when the row exists. For get-or-create: WITH ins AS (INSERT ... ON CONFLICT DO NOTHING RETURNING id) SELECT id FROM ins UNION ALL SELECT id FROM tags WHERE name = $1 LIMIT 1; Want a hand? madeactual.com/#quote
8
A small Node habit for apps in containers: handle SIGTERM so a deploy doesn't cut requests off mid-write. process.on('SIGTERM', () => { server.close(() => process.exit(0)); setTimeout(() => process.exit(1), 8000).unref(); }); Keep the timeout under your kill grace period.
2
1
38
A small JavaScript habit for copying objects before you change them: reach for structuredClone instead of the JSON round-trip. const copy = structuredClone(order); JSON.parse(JSON.stringify(x)) quietly turns Dates into strings, drops undefined fields, and throws on circular references. structuredClone keeps Dates, Maps, Sets and cycles intact, and it's built into Node 17+ and every current browser. It won't copy functions or class methods, so keep it for plain data.
1
18
A small habit for integrations that call someone else's API: when you get a 429, read the Retry-After header before you retry. const wait = Number(res.headers.get('retry-after')) || 2 ** attempt; await new Promise(r => setTimeout(r, wait * 1000 + Math.random() * 500)); The provider tells you how long to back off, and the random jitter keeps your workers from retrying in the same second. No header, or a date instead of seconds, falls back to exponential backoff. Integration keeps tripping rate limits? Tell us about it: madeactual.com/#quote
23
A small Bash habit for scripts that make temp files: create them with mktemp and clean up with a trap, so they're gone even when the script fails halfway. tmp=$(mktemp -d) trap 'rm -rf "$tmp"' EXIT The EXIT trap runs whether the script finishes, dies on an error under set -e, or gets stopped with Ctrl-C, so half-written exports stop piling up in /tmp. What else goes in your script header by default?
1
1
38
A small Git habit for when an urgent fix comes in while you're halfway through a feature: don't stash, open a second working tree. git worktree add -b hotfix/invoice-total ../app-hotfix main That gives you a separate folder on its own branch, sharing the same repo, so your half-done work stays exactly where you left it. Fix, commit, and push from there, then clean up with git worktree remove ../app-hotfix. If you want a small shop that works this way on your app, tell us about it: madeactual.com/#quote
3
3
63
Something we've been doing on every webhook endpoint lately: verify the signature, save the raw request body and headers to a table, return 200, and do the real processing from that table. When the handler has a bug or the vendor quietly changes a field, you fix the code and replay the stored rows instead of asking the vendor to resend. Keep the raw bytes, not parsed JSON, so you can re-check signatures and see exactly what arrived.
1
15
A small Linux habit for cron jobs that sometimes run long: wrap them in flock so a slow run and the next one never overlap. */5 * * * * flock -n /tmp/sync-orders.lock /opt/app/bin/sync-orders The -n means that if the last run still holds the lock, the new one just exits instead of piling up behind it. The lock lets go when the process ends, even if it crashes, so there's nothing stale to clean up by hand. What do you use to keep jobs from stepping on each other?
23
When a bug shows up and nobody knows which commit caused it, let Git hunt for it: git bisect start git bisect bad HEAD git bisect good v1.4.0 git bisect run npm test -- tests/invoice-totals.test.js Git checks out the midpoint, runs the test, and keeps halving until it names the first bad commit. Exit 0 means good, 1 to 124 means bad, 125 means skip this one. Finish with git bisect reset. Want a hand with a stubborn one? madeactual.com/#quote
2
3
41