Blog
Writing grounded in things we actually built. No listicles, no filler.
How to vet an offshore development team before you send money
How to vet offshore teams: review client histories, open repositories, trial tasks, and red flags. Concrete verification steps before you hire or pay.
Should you build your mobile app in C# instead of Flutter or React Native?
Choosing between .NET MAUI, Flutter, and React Native? Learn when MAUI loses (no C# hire, animation-heavy UI) and where it wins (existing .NET backend).
The AI SDKs we reach for in 2026, and when
OpenAI, Anthropic, the Vercel AI SDK, and OpenRouter each solve a different shape of AI project. Here's how we actually choose between them on client work.
Auth: when we build it and when we buy it
A decision guide on OAuth sign-in and provider-managed two-factor authentication versus owning your own credential store, grounded in what compliance and account recovery actually cost.
Background jobs that don't fall over
The patterns that keep scheduled and queued work reliable, idempotency, retries with backoff, dead letters, and keeping the job runner out of the web process.
Bun in production: where it is ready and where it is not
A plain look at what Bun's runtime, installer, bundler, and test runner handle today, and the specific corners where Node still deserves the job.
What five hundred deliveries taught us about client communication
Habits drawn from hundreds of small remote projects rather than one big client story. Short updates instead of long silences, demos instead of descriptions, bad news early, and scheduling that's honest about the timezone gap.
Custom POS or Square: an honest build-vs-buy guide
Off-the-shelf point of sale software has gotten genuinely good. Here's where Square and Lightspeed still win outright, and the specific operational shapes where a custom build earns its cost.
Desktop auto-updates: strategies that survive contact with users
A closer look at how Electron and Tauri handle update delivery, code signing, and failure, checked against their official docs.
Expo or bare React Native in 2026
Where the Expo layer earns its keep, where config plugins and the Expo Modules API cover you, and the narrow case that still justifies dropping to bare React Native.
How we scope fixed-price projects after nine years of freelancing
What years of delivered freelance projects taught us about writing down what's excluded, tying milestones to deliverables instead of dates, and the questions that surface hidden complexity before code starts.
Go, Node, or Bun for your backend
A scenario-based look at Go, Node.js, and Bun for backend work, covering team fluency, concurrency, deployment shape, and ecosystem depth.
How to get your business recommended by ChatGPT
The mechanical side of AI answer engine optimization. Robots.txt, structured data, llms.txt, and markdown for crawlers, built into dawloom.com and checkable on this page right now.
Keeping Shopify in sync with an inventory system
A one-way push to Shopify works until the first order lands from the other side. Here's the architecture for a sync that stays honest, push on change or cron, listen for what comes back, and reconcile what neither side reports.
MCP servers: what they are and when a business actually needs one
What the Model Context Protocol standardizes, what an MCP server can expose, and the honest signs a business should or shouldn't build one yet.
Multi-tenant SaaS: row, schema, or database isolation
Three ways to keep one tenant's data away from another, what each one costs to operate, and how we weigh the tradeoff when a client asks.
Next.js or Astro? We used one for a client's SaaS and the other for this site
A framework comparison grounded in two live Dawloom builds. FurnitureAxis runs on Next.js, dawloom.com runs on Astro, and the reasons are not interchangeable.
The 15-day cooldown that would have stopped this week's npm attack
keyv and cacheable's maintainer account was hijacked on August 4, and the worm that followed reached 434 packages. Here's the one pnpm setting that blocks it, and the prompt we used to roll it out.
OpenAI Agents SDK vs Claude Agent SDK: a closer look
Both SDKs run an agent loop, but they're built around different problems. One coordinates and hands off between agents. The other hands you Claude Code's own execution harness as a library.
React Native or .NET MAUI: we ship both, here is how we choose
An honest comparison of React Native and .NET MAUI for cross-platform mobile, grounded in FurnitureAxis's Expo companion app and what each framework's own docs say about how it actually runs.
What a real estate portal needs that a WordPress theme can't do
Listings ingestion, real filters, map performance, and lead routing all break a theme's assumptions eventually. Here's where that line actually sits, and when a theme is still the right call.
Why we show linked reviews instead of testimonials
Our reviews page links straight to Fiverr and Freelancer profiles instead of running curated quotes, and we don't add review schema to it either. Here's why both choices are deliberate.
What a realtime voice agent actually consists of
Booking and intake lines aren't one AI model answering a phone. They're five separate pieces, transport, model, tool calls, guardrails, and a handoff path, and each one is a real decision.
Replatforming an online store without losing your rankings
A migration checklist for ecommerce replatforms, covering URL mapping, 301s, canonical tags, sitemap cutover, structured data parity, and what to watch in Search Console after launch.
Search: Postgres full-text, Algolia, or Meilisearch
Database-native search covers more than people assume, right up until typo tolerance and faceting become the job. Where that line sits, and what it costs to keep an index in sync once you cross it.
Serialized inventory: why furniture retail can't run on stock counts
Quantity fields work for interchangeable stock. Big-ticket furniture retail needs a record per physical unit, and here's why the difference matters once returns and repairs enter the picture.
Server Actions or API routes in Next.js
Server Actions cover most mutations in a Next.js app, but webhooks, third-party callers, and non-React clients still need a real route. Here's how we decide.
Should this feature be AI? The checklist we run
A five-question checklist for deciding whether a feature actually needs a model, or whether plain code and a database query would serve the client better.
Static, server-rendered, or islands: a guide for people who buy software
A plain-language explainer of the three rendering models, grounded in two live Dawloom builds, so you know what a proposal is asking you to pay for.
Stripe subscriptions: the patterns we reuse
How we structure Stripe billing integrations, webhooks as the source of truth, idempotent handlers, the customer portal instead of a custom billing screen, and test clocks for the renewal that only happens once a quarter.
Svelte 5 runes vs React hooks: we write both every week
A mental-model comparison of Svelte 5's runes and React's hooks, grounded in two things we actually maintain: this site's one Svelte island and FurnitureAxis's React 19 frontend.
Tauri or Electron in 2026: how we decide for desktop apps
An honest, technically grounded comparison of Tauri and Electron for shipping desktop apps, and the questions we actually ask clients before picking one.
The monorepo question for small teams
A monorepo solves one problem well, sharing types between apps without a publish step. For a small team, that's usually the whole decision.
TypeScript strict mode on a hundred-model codebase
What the strict compiler flag actually turns on, what it costs to enable late, and why we leave it on for a Prisma schema that has grown past a hundred models.
The signs your spreadsheet just became an ERP
Four moments when a shared spreadsheet stops behaving like a spreadsheet and starts needing what a real system provides, plus what a first system should actually be.
Why Postgres is our default database
One Postgres instance quietly replaces a document store, a search service, a queue, and a tenant-isolation layer. Here's what it actually covers, and where it stops.
Why this site loads in under a second, and what that has to do with ChatGPT
How we built dawloom.com with Astro, almost no JavaScript, and a Cloudflare Worker that watches AI crawlers. The same decisions we make for client projects, applied to our own.
We had a purple logo. Here's why we walked away from it.
The honest story of the Dawloom rebrand, from a purple brand kit to warm cream and ink, and what studying sites we admire taught us about standing out in the AI era.
Posts also ship as an RSS feed.
Got something to build?
Tell us what you need. An engineer replies, not a sales team.