Two new essays per day, written by our team in collaboration with Claude. Original work only. Filter by category to dial in.
Most cart abandonment recovery advice is stuck in 2019. Here's what we've seen actually recover revenue on Shopify stores in 2026 — and what's a waste of engineering time.
A stuck DynamoDB lock froze every pipeline in the org. Here's what actually happened, why our runbook made it worse, and the guardrails we put in afterward.
Server Actions look like the obvious choice for every mutation in the App Router. They aren't. Here's how we decide between actions and route handlers on real projects, with the failure modes we've hit.
Hermes has been the default in React Native for a while, but the JSC-vs-Hermes decision still shows up in real projects. Here's what's changed, what still bites, and when we'd still reach for JSC.
Most inline validation is punishment dressed up as UX. Here's how to design and build form errors that reduce abandonment instead of causing it.
Long context windows are a trap if you treat them like free storage. Here's how we budget tokens across system prompts, RAG chunks, and tool outputs without wrecking quality.
Faceted filtering on large Shopify catalogs quietly destroys collection page performance. Here's how we architect it to keep TTFB under 400ms without a full replatform.
Cache tags in Next.js finally give us a real invalidation model, but they punish sloppy tagging with stale data and surprise revalidations. Here's how we tag, invalidate, and debug them in production.
Deep links look trivial until a marketing campaign melts down because iOS opens Safari instead of your app. Here's how we wire universal links, App Links, and Expo Router without the usual footguns.
Toasts get dismissed before anyone reads them, stack into unreadable columns, and vanish for screen reader users. Here's the pattern we use instead when work happens off the main thread.
A practical pattern for cutting LLM spend 40–70% without hurting quality: route to a small model first, escalate to a frontier model only when confidence is low. Here's how to build it, measure it, and avoid the traps.
Enterprise procurement cycles kill agency cash flow. A structured, paid two-week pilot lets you land bigger clients faster, prove technical fit, and dodge the RFP death march. Here's how we run them.
Programmatic SEO fails at the data layer, not the template. Here's how we design the content model — entities, attributes, joins, and quality gates — before anyone touches a Handlebars file.
Scripts are gone, Functions are the new contract. Here's what we learned porting discount logic, delivery customizations, and payment gating to Shopify Functions — and where the model still hurts.
A quiet Tuesday, a doubled AWS bill, and a client-side prefetch nobody remembered shipping. Here's how we traced 3.2 TB of surprise S3 egress back to a single React hook.
Streaming SSR is not a free win. Put Suspense in the wrong place and you'll ship a page that feels slower than the blocking version. Here's how we decide where the boundaries go.
Expo's managed workflow got dramatically more capable in 2025, but there's still a line where dev client saves you and bare workflow becomes inevitable. Here's how we decide on real projects.
Most design token systems die the moment they hit a real codebase. Here's how we structure tokens so they actually get used — and stay in sync between Figma, Tailwind, and native.
Prompt caching sounds like free money — bill the big system prompt once, pay pennies after. Reality is messier. Here's what caching actually buys you, and the failure modes that show up once you ship.
Every agency gets the pitch: 'We can't pay cash, but we'll give you equity.' Here's how to tell a real offer from a wish, and how to structure the deal if you say yes.
GSC tells you what Google indexed. Log files tell you what Googlebot actually did on the way there. Here's how we pull signal from server logs to fix crawl waste on large programmatic sites.
Metaobjects promise a schema-first alternative to bolting on another Shopify app. Here's where they actually hold up in production, and where they quietly become your next migration.
We ran the same Node API on Cloud Run and Fargate for six months. Cold starts, egress costs, autoscaling behaviour, and the operational papercuts nobody warns you about.
A war story about how six innocent-looking SDKs turned a lean Next.js App Router build into a 480 KB client bundle, and the audit playbook we now run before every launch.
Background execution is where cross-platform apps quietly fall apart. Here's what actually works on iOS and Android in 2026, and where you should stop fighting the OS.
Empty states are the first thing new users see and the last thing designers polish. Here's how to treat them as a real product surface instead of a placeholder illustration with a sad robot.
JSON mode, strict tool schemas, grammar-constrained decoding — three ways to force LLMs into structured output, each with different failure modes. Here's how we pick, and when we give up and parse text.
Fixed-price projects go sideways because the estimate happens before the thinking does. Here's the paid discovery sprint we run before quoting, and why clients pay for it.
Most programmatic SEO sites don't have a crawl problem, they have a bloat problem. Here's the math we use to decide which templated pages earn their spot in the index and which should never ship.
Checkout.liquid is gone for Plus merchants in 2025, and the extensibility model isn't a drop-in replacement. Here's what actually breaks, what you gain, and how to migrate without torching conversion.
A DynamoDB table that behaved perfectly in load tests fell over during a Black Friday spike. Here's the partition key mistake we made, how we found it, and the redesign that stopped it happening again.
Partial Prerendering promises a static shell with dynamic holes streamed in. Here's what that means for your Core Web Vitals, your cache bill, and the bugs you'll only see under real traffic.
A field guide to the App Store and Play Store rejection reasons that hit React Native and Expo apps hardest in 2026 — and how to ship past them without burning a week of review time.
Loading states are where trust is won or lost. Skeletons, spinners, and doing nothing at all each have a job — most teams pick wrong and pay for it in bounce rate.
Naive exponential backoff will either burn your budget or drop requests your users actually care about. Here's how we design retry logic for Claude, GPT, and Gemini in production.
You built something great for a client and now you want to sell it to ten more. Here's the licensing, IP, and rebuild math that decides whether the spin-out becomes a business or a lawsuit.
When Google ignores your rel=canonical on thousands of pages, the fix isn't a tag change — it's an evidence problem. Here's how we debug it on programmatic sites.
WhatsApp isn't a support channel in emerging markets — it's the storefront. Here's how we wire it into Shopify without turning ops into a call centre.
Sentry said our release was healthy at 99.6% crash-free sessions. Users disagreed. Here's what we found when we stopped trusting the dashboard and started reading the SDK config.
Server Actions look free until traffic shows up. Here's what happens when your form submissions start serializing megabytes of closure state — and how to keep the wheels on.
Push looks simple until you ship. Here's how APNs tokens, FCM HTTP v1, Expo's push service, and iOS focus modes conspire to eat your notifications — and what to actually do about it.
Your designer hates the default focus outline. Your accessibility auditor demands it. Here's how to ship focus indicators that pass WCAG, respect the brand, and actually help keyboard users.
Users don't care about your token/sec chart. They care whether the UI moved. Here's how we stream tool-calling agents so they feel responsive without faking progress or breaking retries.
The first product engineer you hire during an agency-to-product transition will either build your company or quietly break it. Here's how we've seen that hire go right — and wrong.
Most programmatic SEO sites publish once and forget. Here's how we build a refresh queue that prioritizes the right pages, avoids churn edits, and reliably recovers rankings on stale templates.
We've shipped headless Shopify storefronts on both Hydrogen and Next.js. Here's the honest breakdown of tradeoffs, migration pain, and when each stack is the wrong choice.
We migrated a mid-size AWS + Vercel estate from Terraform to Pulumi. Six months in, here's what actually broke, what got better, and the parts we'd do differently.
OTA updates are the best feature of Expo — and the fastest way to get your app pulled from review. Here's how we ship EAS Update safely in 2026, including rollback strategy and the store rules teams keep tripping on.
Hover was designed for a world with one input device. In 2026, most users have three. Here's how to design interaction states that don't quietly break on tablets, foldables, and Windows touchscreens.
AI & LLMsPure vector search misses exact matches. Pure BM25 misses meaning. Here's how we wire them together in production RAG without turning the retrieval layer into a tangle of glue code.
Startups & BusinessRetainers feel like recurring revenue heaven until you look at the timesheets. Here's why most agency retainers quietly bleed margin, and the structural fixes that keep them profitable in year two and three.
SEO & GrowthProgrammatic SEO lives or dies by internal links. Here's how to model, generate, and maintain a link graph across tens of thousands of pages without turning your footer into spam.
E-commerceYour checkout is slow because you keep saying yes to marketing. Here's a repeatable audit framework we use to cut third-party script weight without breaking attribution or the CMO's dashboards.
DevOps & CloudHead sampling threw away the traces we needed. Tail sampling blew up our collector memory. Here's the sampling config we landed on after six months in production.
Web Developmentnext/font promises zero layout shift and no external requests. On mid-range Android, it can also add 200ms to your INP. Here's what we found and how we fixed it.
Mobile DevelopmentIAP looks simple until refunds, family sharing, and grace periods hit production. Here's how we wire React Native purchases in 2026 without trusting the client.
Design & UXDisabled submit buttons feel tidy in Figma and hostile in production. Here's why we've stopped shipping them, and the patterns we reach for instead.
AI & LLMsFixed-size chunking is the default because it's easy. Semantic chunking is trendy because it sounds smart. Here's what actually changes retrieval quality in production RAG systems, and how to decide which one you need.
Startups & BusinessA practical system for handling scope creep with non-technical clients — how we log, price, and communicate change requests without turning every meeting into a negotiation.
Hand-crafted schema doesn't scale, and neither does copying one template across 50k pages. Here's how we generate, validate, and monitor JSON-LD across large programmatic sites without triggering a wave of Search Console errors.
