The stack we ship for SMB AI projects (and what we avoid)

TL;DR

The list we reach for on SMB AI implementation services, with reasons and escape hatches.

• Frontend: Astro 5 + Tailwind 4.
• CMS: Sanity (editorial) or MDX (brochure).
• Backend: Next.js or Fastify on Node / TypeScript; Cloudflare Workers for small edges.
• DB: Postgres on Neon or Supabase. MongoDB only where Change Streams earn it.
• LLMs: Claude for complex reasoning, GPT for general, open models for classification.
• Agent orchestration: Plain code + typed schemas, or LangGraph where branching is heavy.
• Auth: Clerk or Supabase Auth.
• Email: Resend.
• Analytics: PostHog (self-serve) or Umami (privacy-first).
• Search: Pagefind for static, Typesense where we need more.
• Evaluation: Braintrust, Langfuse, or Postgres + Metabase for the cheap route.
• Hosting: Cloudflare Pages + Workers by default.

What follows is the “why.” And at the end, what we don’t ship. If you are not sure which of these tools is appropriate for your shape, that is exactly what the AI readiness audit is built to answer.

---

Why these, not others

Astro 5 + Tailwind 4 (frontend)

• Static-by-default matches SMB needs (mostly marketing + editorial + occasional dashboard). No hydration tax on content pages. This is the default frontend on every custom AI web build we ship.
• Built-in content system, MDX, i18n, good SSR story for the 10% of pages that need it.
• Tailwind 4 is fast, the token story is honest, and escape hatch to plain CSS is clean.
• Escape hatch: Next.js when a project is clearly an app (dashboard, auth, multi-tenant surfaces).

Sanity (CMS)

• Good editorial UX. Editors actually use it.
• GROQ + @sanity/client play nicely with Astro and Next.
• Multi-locale done right (localeString, localeText, localeMarkdown).
• Preview datasets are trivial to set up.
• Escape hatch: MDX in repo for brochure sites with no editorial team, or Payload if we need self-hosted.

Cloudflare Pages + Workers (infra)

• Global CDN for free.
• Preview URL per PR changed how we review content.
• Workers for lightweight APIs (forms, small dynamic endpoints) means we don’t need a separate service.
• Escape hatch: Vercel for Next.js-heavy apps; a VPS when we really need Postgres-adjacent workers.

Postgres on Neon or Supabase (DB)

• Boring, good, supported everywhere.
• Neon’s branching is genuinely useful for preview envs.
• Supabase bundles auth + storage + realtime; helpful on thin-team builds.
• Escape hatch: MongoDB where Change Streams earn their weight (see the orchestrator build log). Not by default.

Claude / GPT / open models (LLMs)

• Claude for complex reasoning, long-context work, and agentic workflows. Default for our own agents.
• GPT for general-purpose and when token cost matters more than edge reasoning.
• Open models (Llama / Qwen / Mistral via Together, Groq, or self-hosted) for classification, structured extraction, anything cheap and high-volume.
• We pick per task and swap without ceremony - abstracted behind a small callModel() wrapper.
• Escape hatch: Gemini where long-video or massive context windows earn it.

Agent orchestration (plain code first)

• Under ~10 steps with clear branching, plain code + typed schemas wins. Readable, debuggable, versionable.
• LangGraph when branching is genuinely complex (multi-agent, cyclic, with retries and interrupts).
• We avoid: heavy frameworks that hide the control flow. Debugging an agent is hard enough; don’t add a DSL.

Auth (Clerk or Supabase Auth)

• Clerk: easy to ship, great dev UX, pricey at scale - fine for early SMB products.
• Supabase Auth: free, self-hostable, integrated with Supabase DB.
• Escape hatch: Auth.js where we want everything in-repo.

Resend (email)

• Good API, good deliverability, good DX.
• Cloudflare Worker + Resend handles forms cleanly.
• Escape hatch: Postmark for transactional-heavy sends.

PostHog (analytics + feature flags + session replay)

• Self-hostable, EU region available. No third-party tracking cookies.
• Feature flags + experiments + analytics in one product is a real productivity win on SMB projects.
• Escape hatch: Umami where we want privacy-first minimalism.

Pagefind (search)

• Client-side search, prebuilt at build time, zero infra.
• For editorial-scale sites, it’s a strictly better choice than hosted search.
• Escape hatch: Typesense (self-hostable) when the corpus outgrows static.

Evaluation (Braintrust / Langfuse / Postgres + Metabase)

• You have to measure agent quality. You don’t need to pay a lot for it.
• Braintrust and Langfuse are the polished options.
• Postgres + Metabase is the honest cheap option. Works.

---

What we don’t ship

• WordPress for new builds. Inheritance, sure. Starting fresh, no. Performance and security hygiene are worse.
• Webflow for anything editorial-heavy. Great for single-page + small marketing sites. Hits a wall at scale.
• Framer as a production site. Lovely for prototypes. Export path is wrong for production.
• “No-code AI” platforms (naming none). Fine for a demo, impossible to hand over as source.
• Heavy JavaScript frameworks on content-heavy sites. Next.js is great for apps, often too much for a marketing site.
• Redis / Kafka on under-100-RPS systems. Overkill.
• Vector DBs as a default. We’ll use one when the retrieval shape demands it (semantic over 10K+ docs). We won’t add one for a 500-row knowledge base - Postgres + pg_trgm / full-text works.
• “Train a custom model from scratch.” Almost always unnecessary for SMB work. Fine-tune at most, and usually not even that.
• Frontier model for every call. Wasteful. Match the model to the task.
• Model-agnostic “AI agency” framing. We name what we use. Clients get to audit it.

The meta-rule

Pick tools you can maintain forever. Ship the boring choice. Save the weird choice for when the constraints demand it. Write down why each thing is in the stack. When the reason stops being true, swap it out.

---

Want this stack on your project? Scope a build →

Not sure what’s right? Free AI Readiness Audit →