The 2026 AI Solopreneur Stack

This is a stack guide for one-person AI product companies as of May 2026. It assumes the founder writes code, ships to production, and needs to keep monthly fixed costs survivable while validating product-market fit. It is not a benchmarking comparison of which model has higher MMLU scores. It is a list of vendor choices that work in production today, with prices, decision rules, and the dollar math for three operating scales.

1. What the 2026 AI solo stack is

An AI-first SaaS at solo scale needs seven discrete capabilities: serve a UI, authenticate users, store data, embed and retrieve documents, call a frontier model, take payment, and surface errors. Each capability has a default vendor pick that handles 90% of solo workloads with no devops. The stack below assumes a TypeScript / Python codebase deployed to a serverless edge, with all heavy compute happening either in-vendor or behind a model API.

The shape:

• Frontend + edge compute: Cloudflare Workers or Vercel
• Database: Supabase (Postgres + auth + storage) or Neon (Postgres only)
• Vector store: pgvector inside Supabase, or Pinecone serverless
• Model: Claude (Anthropic), GPT (OpenAI), or Gemini (Google)
• Auth: Clerk, Supabase Auth, or WorkOS
• Payments: Stripe, Paddle, or LemonSqueezy
• Observability: Sentry for errors, Axiom or Cloudflare Logs for events

At pre-revenue scale, every vendor in this list has a free tier sufficient to ship and validate. Total monthly cost on the free tiers is under $30, mostly model API spend during development.

2. Model layer: Claude, GPT, Gemini

As of May 2026, Anthropic Claude, OpenAI GPT, and Google Gemini all expose comparable APIs at comparable price points. The differences that matter at solo scale are pricing per million tokens, context length, and feature support (prompt caching, batch API, structured outputs).

Published rates as of access date^[1][2][3]:

Tier              Model               Input $/M tok   Output $/M tok   Context
Frontier          Claude Opus 4       $15.00          $75.00           200k
Frontier          GPT-4 Turbo         $10.00          $30.00           128k
Frontier          Gemini 1.5 Pro      $3.50           $10.50           1M
Workhorse         Claude Sonnet 4     $3.00           $15.00           200k
Workhorse         GPT-4o              $5.00           $15.00           128k
Workhorse         Gemini 1.5 Flash    $0.075          $0.30            1M
Cheap             Claude Haiku 3.5    $0.80           $4.00            200k
Cheap             GPT-3.5 Turbo       $0.50           $1.50            16k
Cheap             Gemini 1.5 Flash 8B $0.0375          $0.15            1M

Decision rules at solo scale. Use Claude Sonnet for code-heavy or reasoning-heavy paths where output quality matters more than per-token cost. Use Gemini 1.5 Flash for high-volume cheap paths (classification, summarization at scale) where context length matters. Use GPT-4o when you need broad ecosystem support (function calling tooling, structured outputs, plugin breadth). The cost difference between providers at the workhorse tier is 3-5x; at the cheap tier it is 10-20x. Pick by workload, not by brand loyalty.

One rule that pays off: budget by route, not by month. Tag each API call with the route name and aggregate spend per route weekly. Solo founders who track spend at the route level catch runaway loops in days; founders who track only monthly totals catch them in cycles after the bill arrives. The AI stack cost calculator handles the per-route math.

3. Embeddings and vector storage

Vector storage has two viable solo paths in 2026: pgvector inside Postgres, or Pinecone serverless. Both work at solo scale; the choice is determined by whether you already operate Postgres for your application data.

pgvector is a Postgres extension. If your application is on Supabase or Neon, pgvector adds vector search to your existing database with no additional vendor. Operationally simpler: one connection string, one backup story, one billing line. Limits: pgvector's HNSW index works well up to a few million vectors; beyond that, dedicated vector databases are faster and cheaper.

Pinecone serverless prices at $0.33 per million write units and $8.25 per million read units, with no fixed minimum^[4]. For a product with 100k embedded documents and 1k queries per day, Pinecone serverless costs roughly $5 to $10 per month all-in. Operationally a separate vendor, but no scaling work required.

The decision rule. If you already run Postgres, default to pgvector and migrate to Pinecone only when index size or query latency become measured problems. If you do not run Postgres, default to Pinecone serverless and add Postgres later when relational data forces it. Avoid running a third option (Weaviate, Qdrant, Chroma self-hosted) at solo scale. The operational tax of a third vendor or a self-hosted database is not worth the marginal performance gain.

4. Compute, edge, and hosting

Serverless edge platforms (Cloudflare Workers, Vercel, AWS Lambda) replace traditional server hosting at solo scale. The two defaults are Cloudflare Workers and Vercel. Both run JavaScript and TypeScript at edge locations globally; both have generous free tiers; both integrate with Git for deploy-on-push.

Cloudflare Workers free tier covers 100,000 requests per day with no credit card^[5]. Paid tier starts at $5/month for 10 million requests. Workers KV, R2 (object storage), D1 (SQLite at edge), and Queues are billed separately but sit in the cents-per-million range. For pure-API products with no SSR rendering, Cloudflare is the cheapest option at every scale.

Vercel free tier (Hobby) covers personal use and unlimited deployments^[6]. Pro tier is $20/month per seat with included bandwidth and function execution. Vercel's integration with Next.js is tighter than Cloudflare's, and the developer experience for static + SSR sites is the best in market. Pick Vercel if your product is a Next.js app with significant SSR; pick Cloudflare if your product is mostly API endpoints behind a static frontend.

Both providers will be sufficient at solo scale. Avoid migrating between them unless you hit a measured cost or feature limit. The migration cost (rewriting deployment, environment variables, cron jobs, edge config) typically exceeds two months of bill savings.

5. Payments: Stripe, Paddle, LemonSqueezy

Three payment providers dominate solo SaaS in 2026: Stripe, Paddle, and LemonSqueezy. They differ on one axis that matters more than per-transaction fees: who handles tax, VAT, and global compliance.

Stripe is a payment processor. Standard rate is 2.9% + $0.30 per US transaction^[7]. Stripe does not file VAT returns or act as merchant of record. You are responsible for tax registration in jurisdictions where you sell. Stripe Tax automates calculation and reporting but does not assume tax liability. For solo founders selling US-only or B2B-only with reverse-charge VAT, Stripe is the lightest option.

Paddle is a merchant of record (MoR). Paddle charges 5% + $0.50 per transaction^[8] and assumes tax liability globally. Paddle files VAT returns in the EU, GST in Australia, sales tax in US states, and remits on your behalf. The 2-3% premium over Stripe buys you out of tax compliance for international sales. For solo founders selling globally to consumers or small businesses, Paddle eliminates a real compliance burden.

LemonSqueezy is also a merchant of record. LemonSqueezy charges 5% + $0.50 per transaction with VAT and sales tax handling included^[9]. The product is similar to Paddle but with a more developer-friendly API and faster onboarding for first-time founders. For digital products under $50k/month in volume, LemonSqueezy's onboarding path is the fastest of the three.

Decision rule for solo founders. Default to LemonSqueezy or Paddle if you sell globally to consumers. Default to Stripe if you sell US-only B2B and have a CPA filing returns for you. Switch only when transaction volume crosses $50k/month, at which point the 2-3% MoR premium starts to matter and the in-house tax compliance cost starts to be defensible.

6. Authentication: Clerk, Supabase, WorkOS

Authentication has three viable solo paths in 2026: Clerk, Supabase Auth, and WorkOS. The choice depends on your customer profile.

Clerk is a hosted authentication service with React, Next.js, and Astro components prebuilt. Free tier covers up to 10,000 monthly active users^[10]; paid tier starts at $25/month. Clerk handles email + password, magic links, OAuth providers, MFA, organizations, and session management out of the box. Default pick for B2C and small-team-B2B products under 10k MAU.

Supabase Auth is bundled into the Supabase platform^[11]. If you already use Supabase as your database, Supabase Auth is the operationally simplest choice — auth, database, and row-level security policies all live in one vendor. Free tier covers 50,000 monthly active users; paid tier starts at $25/month. Supabase Auth lacks Clerk's prebuilt UI components but is more flexible for backend-heavy applications.

WorkOS handles enterprise SSO (SAML, SCIM provisioning, audit logs). Pricing is $125 per SSO connection per month after a free first connection. Pick WorkOS only if your sales motion includes enterprise customers who require SSO. At solo scale, this usually means contracts above $20k ACV; below that, customers will accept email + password or Google OAuth.

Decision rule. Start with Clerk or Supabase Auth based on which database you use. Add WorkOS only after a real customer has asked for SSO with budget attached.

7. Observability: Sentry and Axiom

At solo scale, observability has two parts: error tracking and event logging. APM (full distributed tracing, percentile latency dashboards) is overkill for sub-100k MAU products and adds $200-$1000/month with no marginal value over the simpler tools.

Sentry handles errors. Free Developer tier covers 5,000 errors per month with all features^[12]. Paid tier starts at $26/month for 50,000 errors. Sentry captures stack traces, request context, and release-tagging out of the box for every major framework. Default pick.

For event logging (login events, payment events, model API calls with cost tags), the cheapest path is the built-in log drain on your edge platform. Cloudflare Logs ship to R2 or external destinations. Vercel Logs Drain ships to S3 or Datadog. Axiom and Logtail are commercial alternatives that handle structured logs with query interfaces; both have generous free tiers.

Avoid stacking three monitoring tools. One error tracker plus one log drain is sufficient at solo scale. Adding Datadog, New Relic, or Honeycomb at sub-100k MAU spends time configuring dashboards no one looks at.

8. Total monthly cost at three scales

The dollar math for the canonical solo stack at three scales: pre-revenue MVP, $5k MRR, and $50k MRR. All numbers in USD and based on the published rates above.

Component             Pre-rev MVP    $5k MRR        $50k MRR
Edge compute          $0 free        $20 Vercel     $20 Vercel
Database (Supabase)   $0 free        $25 Pro        $599 Team
Vector (pgvector)     $0 included    $0 included    $0 included
Model API (Claude)    $20 dev usage  $200 prod      $1,800 prod
Auth (Clerk)          $0 free        $25 Pro        $125 Business
Payments (LSqueezy)   $0 fixed       5%+$0.50/tx    5%+$0.50/tx
Sentry                $0 free        $26 Team       $80 Business
Log drain (Axiom)     $0 free        $0 free        $25 paid
TOTAL FIXED           $20            $296           $2,649
PAYMENTS (variable)   -              ~$300/mo       ~$3,000/mo
TOTAL ALL-IN          ~$20           ~$596          ~$5,649

The pattern. Fixed infrastructure stays under $50/month at MVP scale and under $3k/month at $50k MRR. Payments processing scales linearly with revenue at 5-7% of GMV. The model API line is the only one that varies materially with usage; if your application is high-volume cheap inference, Gemini Flash will cut the model line by 5-10x. If your application is reasoning-heavy with low volume, Claude Sonnet at $200/month is correctly the largest variable cost.

The single largest cost mistake at solo scale is over-provisioning monitoring and database. A founder who picks Datadog ($300/month minimum) plus a managed Postgres service ($150/month minimum) on day one has spent $450/month before writing code. The same product on Sentry free + Supabase free runs at $0 until paying customers exist.

9. Decision rules for swaps

The stack above is the default. Real products diverge. Six rules for when to swap a component.

• Swap models when route-level cost exceeds $5/customer/month. If a single feature consumes more than $5 of API spend per active customer, route that feature to a cheaper tier (Sonnet to Haiku, GPT-4o to GPT-3.5, Gemini Pro to Flash) and measure quality impact with a held-out eval set. Cost-tier downgrades that hold quality save the most money.
• Swap to Pinecone when pgvector hits 5M vectors or 200ms p95 query latency. Below those thresholds, pgvector is faster to operate. Above them, the dedicated vector store amortizes its operational cost.
• Swap from Cloudflare to Vercel only if you adopt Next.js with significant SSR. Both are sufficient at solo scale. Migration is expensive; do it for measured product reasons, not preference.
• Swap from Stripe to a MoR when international sales exceed 25% of revenue. Below 25%, the in-house tax compliance is manageable. Above 25%, the MoR premium pays for itself in compliance time saved.
• Swap auth from Clerk to WorkOS when enterprise contracts require SSO. Not before. Adding WorkOS preemptively burns $125/month on a feature no customer is buying.
• Add APM (Datadog, Honeycomb) only at $100k MRR or 100k MAU, whichever comes first. Below those thresholds, Sentry plus structured logs catch every problem you will actually act on. APM is a $200-$1000/month bet on dashboards that solo founders rarely have time to read.

The 2026 AI solopreneur stack is six vendors at $300/month at $5k MRR, with two of those lines (model API and payments) scaling with revenue. Most of the cost optimization at solo scale comes from picking the right tier of model for each route, not from switching vendors. Most of the operational time savings come from running fewer vendors, not more. The rule that produces both: pick the smallest viable stack, instrument it well, and measure before you change anything.