Insights
Practical writing on
building real systems.
Practical writing from real client work — integrations, AI, custom builds and the decisions behind them. No fluff, no listicles, no cheap takes.
Browse all
Showing 58 of 58 articles
No articles match those filters.
Try a different search, or clear the category filter.
Cliniko API integrations: practitioner's guide for AU clinics
A practitioner's view of the Cliniko API surface — what it covers, where it stops, and the integration patterns Australian allied-health practices use to build the layer Cliniko doesn't ship natively.
Mindbody to Cliniko migration: technical realities for AU clinics
The technical realities of moving an Australian wellness, recovery or multi-modality clinic off Mindbody and onto Cliniko — what transfers cleanly, what doesn't, where the workarounds live, and what timeline to plan against.
simPRO API integrations: connecting AU trades to the stack
A practical view of the simPRO API surface — what it covers, where it stops, and the integration patterns Australian commercial trades operators use to build the layer simPRO doesn't ship natively.
ActiveCampaign for Adelaide and Australian businesses: integration patterns
How Adelaide and Australian businesses extend ActiveCampaign with custom integrations — lifecycle automation from operational systems, Australian compliance, cross-domain attribution, and reporting beyond the native dashboards.
Tradify integrations for Australian trades businesses: what custom builds add
How Australian trades businesses extend Tradify with custom integrations — lead capture to quote, accounting reconciliation, customer portal, job costing, and the field tools Tradify doesn't cover natively.
After Sendle: architecting Shopify and WooCommerce shipping so the next carrier failure doesn't crash your store
Sendle's January 2026 shutdown left thousands of Australian stores with broken labels overnight. The reflexive fix is migrating to another single carrier. That's how the next outage happens. The carrier-agnostic patterns that survive.
Should you sell on Catch, Kogan, MyDeal or Amazon Australia? An honest margin analysis before you build the integration
Every marketplace integration article in the AU SERPs is a sales page for the integration tool. None answer the question that matters: does the marketplace economics work for your product, before you spend on the build?
Building a B2B wholesale portal for an Australian brand: architecture patterns beyond Shopify B2B
Shopify B2B handles basic wholesale ordering. Tiered customer pricing, AU freight zones, Net-30 terms, ERP-driven inventory, multi-warehouse fulfilment, and sales-rep order entry are where it stops. The patterns that scale past it.
When Cin7, Unleashed, or Katana isn't the right answer: an inventory architecture framework for Australian multi-channel sellers
The default advice is to pick an IMS — usually Cin7, Unleashed, or Katana. For most stores that's right. For some it's the most expensive integration project they'll regret. The shapes where each platform fits and where custom architecture pays back.
Smokeball API integrations for Australian law firms
How Australian law firms extend Smokeball with custom integrations — website intake to matter creation, trust accounting reconciliation, client communication, and the cross-matter reporting Smokeball doesn't do natively.
Mindbody alternatives in Australia: when to migrate, and to what
An honest read on the Mindbody alternatives Australian boutique fitness, wellness and recovery businesses actually consider — and the decision points that determine which platform fits which business shape.
Agentive AI in Australian legal practice: what's possible, what's gated, and what isn't yet
A working overview of where autonomous AI agents fit in Australian law-firm operations today — the frameworks (OpenClaw, Hermes Agent), the model question, the LEAP API surface, and the licensing and regulatory constraints that shape what can actually be built.
Nookal integrations for multi-practitioner Australian clinics
Where Nookal earns its place over Cliniko and Halaxy for multi-practitioner clinics — and the integration patterns that turn a strong PMS into a complete operational platform.
Halaxy API: what you can and can't build with it
A practitioner's view of the Halaxy API surface — what it covers, where it stops, and the integration patterns Australian allied-health practices use to bridge the gaps before considering a platform move.
ConvertKit integrations: the five patterns we build when Zapier isn't enough
Five custom integration patterns we keep building for ConvertKit — Bonjoro, Slack, Facebook Custom Audiences, Airtable, Kajabi — and the decision points where no-code platforms run out of road.
Canvas LMS integrations in Australia: what custom builds actually look like
What it really takes to integrate Canvas LMS with the rest of an Australian RTO's stack — student data, AVETMISS reporting, finance and SSO — and where the off-the-shelf connectors stop being enough.
AI digital marketing agencies in Adelaide: where AI actually helps (and where it doesn't, yet)
An honest look at what an AI-led digital agency in Adelaide can and can't do for Australian businesses right now — and the questions to ask before you sign anything.
Best Practice software API: what you can and can't build with it
A practitioner's view of the Best Practice Software API — what the integration surface actually covers, where it stops, and the patterns Australian medical practices use to bridge the gaps.
Brevity Care for NDIS providers: the integrations worth building
A look at where Brevity Care's built-in features stop and where custom integrations earn their place — claims, rostering, family communication, and the operational reporting NDIS providers actually need.
Charity CRM and accounting software in Australia: how the stacks actually fit together
A practitioner's look at the Australian charity CRM and accounting software landscape — what the all-in-one platforms cover, where they stop, and the integration patterns that hold a fundraising operation together.
Integrating Leap legal practice management: the workflows worth automating
A look at where Leap's built-in automation runs out and where custom integration earns its place — intake, trust accounting, document generation, and the law-firm-specific reporting that's usually built around Leap rather than inside it.
ezyVet integrations: vet practice management API guide for AU clinics
Where ezyVet's native features stop and where custom integrations earn their place — online booking, reminder workflows, accounting, and the operational reporting vet clinic owners actually use.
Carelink+ integrations: extending community care software beyond the dashboard
Where Carelink+ covers the operational core well and where custom integrations earn their place — claims, rostering edges, family communication and reporting beyond the native views.
Ecommerce accounting integrations: Shopify and WooCommerce to Xero or MYOB without spreadsheets
What it actually takes to connect ecommerce sales to accounting in Australia — order flows, GST treatment, inventory, refunds, and the integration patterns that survive Black Friday.
What AI actually costs to run in production
AI demos are cheap. Production is not. Where the money actually goes when you ship an AI feature, and how to size the engineering investment around the model.
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.