Writing / A working notebook
Notes from
the workbench.
Things I’m building, things that broke, and what I learned along the way. Slow on purpose.
How Much Does Custom Software Actually Cost?
Custom software can cost anywhere from RM20,000 to RM500,000 or more. Here's a plain-language breakdown of development, maintenance, and hidden fees so you can decide if the investment pays off for your business.
The Unreasonable Effectiveness of Simple Static Site Generators in 2026
Forget the JAMstack hype cycle. Plain HTML generated from Markdown with a makefile still beats most modern stacks for docs, blogs, and internal tools. Here's why, and when to resist the urge to add a JavaScript framework.
When Your Business Systems Are Just Digital Paper
Your software looks like progress, but if it just moves paper to a screen, you're paying a silent tax in time, errors, and trust. Here's how to spot the difference between digitized and truly automated, and why it hits your bottom line.
What 'Single Source of Truth' Actually Means for Your Business (and Why It's Not Just Another Buzzword)
You already have a single source of truth. It's probably a spreadsheet, a group chat, or someone's memory. The problem is everyone has a different one. Here's what fixing that actually looks like, in plain language.
The Hidden Failure Mode in Serverless: Cold Start Isn't Your Biggest Problem
Cold start gets all the attention, but eventual consistency in event-driven serverless workflows is what really bites. Duplicate events, out-of-order updates, and silent data loss happen when handlers fan out and retry.
The True Cost of Inventory Stockouts: How Running Out Quietly Erodes Both Revenue and Customer Trust
Stockouts don't just mean a missed sale today. They trigger lost future purchases, drive customers to competitors, and mask operational inefficiencies that compound over time.
WebAssembly Is Not Just for the Browser Anymore: Running Wasm on the Server with Rust and WASI
Server-side WebAssembly with Rust and WASI is challenging containers for edge and multi-tenant workloads. I dig into the real capabilities and the hard limitations you won't see in the hype.
What a 'Digital Twin' Means for Your Business (and Why It's Not Just for Factories)
A digital twin is a virtual copy of your operations that lets you test changes before you make them. Think of it as a sandbox for your business: you can spot bottlenecks, try new workflows, and see what breaks, all without touching the real thing.
Why Your API Rate Limiter Is Costing You Real Traffic
Misconfigured rate limits don't just reject spam. They reject paying customers during traffic spikes, silently kill retries, and hide themselves behind generic 429 errors. Here's what actually happens when you measure it.
When Your Inventory Math Doesn't Match What's Actually in the Warehouse: How Rounding Errors and Manual Updates Turn Small Problems Into Supply Chain Disasters
Small inventory errors compound fast. Rounding mistakes, manual data entry delays, and systems that don't talk to each other create cascading supply chain failures that cost more to fix than the system that would prevent them.
Why Your Vendor Lock-In Isn't Just a Tech Problem—It's Bleeding Your Operating Budget
Vendor lock-in costs most businesses real money every month: wasted time, duplicated effort, and the panic bill when you finally want to leave. Here's what it actually costs, and how to spot it before you're trapped.
Why Your Team Can't Keep Track of What's Actually Completed (And Why Project Management Chaos Costs More Than You Think)
Most SMEs run on status meetings and Slack sprawl instead of a real view of what's done and what's blocked. Here's the actual cost of that chaos, and when a proper project system pays for itself.
The Docker Networking Trap: Why Your Containers Appear Healthy While Traffic Disappears
Container logs show success. Health checks pass. Yet traffic between services stops at the network boundary. This is how silent DNS and port-binding failures hide in plain sight—and how to find them before they crush production.
When You're Paying for Two Systems to Do One Job: Spotting Redundancy Before It Becomes Reckless
Growing teams often license overlapping tools without realizing it. Here's how to audit what you actually have, measure what's being wasted, and know exactly when consolidation pays for itself.
Database Connection Pooling in Production: When Your Connections Start Hanging and Nothing Tells You Why
Connection pools look transparent until you scale. This is where the silent cascades start: how to measure pool exhaustion before it kills your app, and the exact metrics most teams miss.
Building Payment Processing Systems That Don't Leak Money: Where Queue Design Meets Reconciliation
Most payment systems leak. Not because the code is wrong, but because the queue that orchestrates them treats money like any other message. I'll show you where.
When Your Approval Workflows Are Actually Decision Bottlenecks: How to Measure the Real Cost of Broken Sign-Off Processes
Manual approval chains, unclear authority, and email-based sign-offs don't just slow decisions. They cost you 5+ hours a week in management overhead and compound errors that nobody catches until it's expensive. Here's what that actually costs, and when a proper workflow system pays for itself.
The Real Cost of Tribal Knowledge: Why Your Best Employee's Brain Is Your Biggest Liability
When critical business processes live only in one person's head, you're not gaining flexibility. You're building a time bomb. Here's what it actually costs, and when fixing it becomes cheaper than ignoring it.
Async/Await in Production: When Your Task Queue Becomes a Footgun
Most backends start with fire-and-forget async tasks and lose data without knowing it. Here's the concrete difference between "it worked in testing" and actually guaranteed delivery, and why you'll rebuild this twice.
When Growth Stops Fitting in Your Email Inbox: How to Know When Your Communication System Is Secretly Costing You
Email works fine until it doesn't. By then, you're losing messages, duplicating work, slowing down new hires, and frustrating clients. Here's how to measure the real cost and when a proper communication system actually pays for itself.
The Hidden Cost of Spreadsheet Sprawl: When Your Data Lives in 12 Different Files
Spreadsheets aren't the problem. But when your truth is split across a dozen files with no single source, you're bleeding money in silence: wasted hours, duplicate work, wrong decisions, and errors no one catches until it's too late. Here's what it actually costs, and when fixing it pays for itself.
When Manual Processes Start Costing More Than Software: How to Know When Your Workarounds Have Become Your Real Problem
Most SME owners don't notice the bleeding until they've already lost months of labor hours to manual work that software could handle in seconds. Here's how to do the math before it gets worse.
Why Your Error Budget Is Lying to You (And How Observability Actually Fixes It)
Error budgets sound clean in theory but fail silently when you can't see where the unreliability actually is. Here's how to build observability that makes them real.
When Your Team Stops Talking to the Database Directly — Why That Matters
Direct database access feels fast until someone deletes a year of records by accident. Here's what happens when you add an API layer, what it costs, and the exact warning signs your business has outgrown the shortcut.
Claude Code, but for backend people
Not a demo reel. How I actually use Claude Code for queue workers, schema migrations, and payment code where wrong answers cost RM.
Write a blog in 2026 without sounding like ChatGPT
Dev blogs are drowning in generated prose. Here are five rules to write with actual voice before readers learn to skip yours on sight.
Opus 4.7 is slower on my codebase. Here's where the benchmarks lie.
Anthropic's SWE-bench Pro jump is real. But adaptive thinking adds latency that benchmarks absorb and surgical codebases do not.
Next.js 16 broke my blog. The fix was three lines, the lesson was bigger.
Vercel blocked my deploy over an RCE advisory, the upgrade introduced a new default that silently stripped JSX props, and it took a few hours to find the two config flags.
Malaysia's 900 AI startups need backend engineers, not prompt engineers
The capital has arrived. The data centers are built. The thing Malaysia is still short of is the decade-accumulated skill of building systems that stay correct.
FPX, DuitNow, and why OAuth alone won't save your Malaysian fintech
OAuth gets you past the login screen. Idempotency, mandate state machines, and settlement-file reconciliation are what keep production from burning.
Postgres + Drizzle, after a year
Not a tutorial. Lessons from a year of running Drizzle in production across JomJual, Lunara, and a few side builds.
One VPS, three side projects, zero cloud bill
Docker Compose, Nginx, a 2GB Hetzner box, and the indie-infra setup I use when I do not want a cloud invoice on my personal card.
Reading Malaysian payment rails
FPX, DuitNow, TNG, Curlec, iPay88. A short guide to the local payment landscape without the Silicon Valley lens.
Solidity, learning diary
Notes from a web2 engineer writing real smart contracts. Foundry, gas math, and the mental shift that actually matters.