Insights
Practical writing on
building real systems.
One thoughtful piece per month, written from real client work. No fluff, no listicles, no cheap takes.
Recent
Why integrations break in production (and what to design for)
Every integration that "just calls an API" eventually breaks. The five places they fail first, and the design patterns that keep them running unattended.
The hidden costs of SaaS once your business is established
The per-seat licence is the visible cost. Integration tax, lock-in, configuration drift, and the seat tax at scale are the SaaS costs no one quotes up front.
Red flags to watch for when hiring a development agency
The signals that separate agencies who deliver from agencies who disappear after the deposit. Twelve practical red flags from twenty-plus years of seeing them.
Build vs Buy: A decision framework for custom software
A practical framework for deciding when SaaS is enough, when low-code wins, and when custom software is genuinely the right answer — before you spend a dollar.
GoHighLevel vs HubSpot vs ActiveCampaign for SMB
A practical comparison of GoHighLevel, HubSpot, and ActiveCampaign for service-based SMBs. Where each one wins, where each one breaks, and how to choose.
Total cost of ownership: SaaS vs custom software, properly compared
Most SaaS-vs-custom comparisons stop at licence vs build quote. The real comparison includes integration, lock-in, training, and the seat tax.
Why we build marketing sites on Astro, not WordPress
An honest look at why most premium marketing sites should not be built on WordPress in 2026 — and what the alternative actually looks like in practice.
When WordPress is the right answer (and when it really isn't)
WordPress runs 43% of the web. For some projects it's genuinely the right pick. For others it's a long-term liability. The honest test for which is which.
SaaS lock-in: five signs you're already paying it
Vendor lock-in isn't something that happens later — it's something that compounds quietly. Five practical signs your business is already paying a SaaS lock-in tax.
AI automations that actually ship — not demo-ware
AI demos are easy. AI in production is hard. The real engineering between a slick demo and an automation you can trust to run unattended.
iPaaS vs custom integration code: where each one fits
When Zapier, Make, or n8n are genuinely the right answer, when custom integration code wins, and how to tell the difference before the build cost mounts.
Webhook patterns that don't fall over at scale
Webhooks are the fast path between systems. They're also where a lot of integrations quietly lose data. The patterns that survive real production volume.
Designing for API rate limits before they bite
Most rate-limit incidents are avoidable. The design patterns that keep integrations running through backfills, traffic spikes, and shared API quotas.
Integration testing: the layer most teams skip
Unit tests test functions. End-to-end tests test the UI. The integration layer between systems usually has neither — and that's where most production incidents live.
Where AI breaks: the prompts you can't deploy to production
A working AI demo isn't a working production system. Five categories where current models reliably fail, and how to spot them before you build.
RAG explained for business owners (without the jargon)
What retrieval-augmented generation actually is, why it matters for business AI, and the practical decisions every owner should understand first.
Claude vs GPT vs Gemini for business automation in 2026
Where each frontier model genuinely shines and where it falls short. A practical comparison for business owners commissioning AI work in 2026.
Keeping humans in the AI loop: a practical guide
Fully autonomous AI is a marketing pitch. Production AI keeps humans in the loop. Where to put them, when to escalate, and how to design for it.
Core Web Vitals in 2026: what changed and what still matters
INP replaced FID, thresholds tightened, and Core Web Vitals matter more than ever for ranking. The current state of CWV and what it takes to pass.
The performance budget every business website should have
A performance budget turns "the site feels slow" into a number the team can hit and hold. The metrics that matter, the budgets that work, and how to enforce them.
Image delivery: the optimisation most agencies skip
Most sites ship 2–5× more image weight than they need to. Modern image delivery is solved — agencies just don't implement it. The full pipeline.
Headless CMS in 2026: when it's worth the complexity
Headless CMS unlocks fast modern frontends but adds real cost. The cases where headless wins, and where traditional WordPress or a static repo win.
The death of jQuery and the modern stack that replaced it
jQuery solved real problems. Most of those problems are solved better by the browser today. The honest map of what to use instead, by use case.
Migrating from HubSpot to GoHighLevel: the gotchas
Migrating off HubSpot to GoHighLevel: what moves cleanly, what has to be rebuilt, and the gotchas that cost weeks if you don't plan for them.
Custom GoHighLevel: when no-code stops being enough
GoHighLevel's no-code workflows are great until they're not. The signals that you've outgrown the visual builder, and what custom GHL development actually involves.
Why skipping the discovery phase costs three times more
Discovery feels expensive because nothing is being built. The cost of skipping it shows up later — scope changes, missed deadlines, the wrong system shipped on time.
Fixed-price vs time-and-materials for custom software
Both contract models have legitimate uses. The honest comparison of fixed-price vs T&M for custom software, and the hybrid model that often wins.
Why bad briefs lead to bad builds (and how to write a good one)
Most "bad" software projects had bad briefs — features instead of outcomes, technologies instead of problems. The structure of a brief that produces a good build.
Choosing an Adelaide development partner: what actually matters
How to evaluate Adelaide web development agencies for technical capability, fit, and trust. The questions that matter when commissioning custom software in SA.
Why Australian businesses are slow to adopt AI (and the ones that aren't)
Australian SMBs trail US/UK counterparts by 12–24 months on AI adoption. The reasons are structural, not cultural — and the gap is starting to matter competitively.
The case for an Australian development team for Australian businesses
Offshore development looks cheaper per hour. Total cost is rarely cheaper once communication, timezone, quality, and IP are honestly counted.
When to rewrite vs refactor a legacy system
Full rewrites usually cost more than they look, even when the legacy feels unworkable. The honest framework for choosing between rewrite and refactor.
Let’s build something
The right system,
built once, properly.
If your business is ready to scale beyond what off-the-shelf tools can support — we should talk.