The Indie Developer's AI Stack for Shipping Products 2026

An indie developer's AI stack in 2026 is a deliberate combination of coding tools (Cursor, Claude Code, Copilot), models (hosted GPT-4o-class and Claude, plus self-hosted Llama for batch jobs), backend infra (a simple Node or Python API with Postgres), frontend frameworks (Next.js for web, React Native for mobile), and workflow automation (n8n) — all chosen to minimize the engineering work between idea and shipped feature.

The point of an indie stack is not to be impressive. It is to be small enough that one person can hold the whole thing in their head, debug it on a Sunday night, and deploy a fix without an on-call rotation. The tools above hit that bar.

This guide is the stack we use at Codmaker to build PlantDoc, Fish Identifier, AdMetric Pro, Tahadi Alkalimat, and this website. It is opinionated. We will explain why each choice beats the alternatives we tested.

Three options for any piece of your stack: build it yourself, buy a SaaS that does it, or borrow open-source that you operate yourself. The right choice depends on three questions.

How much does it differentiate your product? If a feature is core to your differentiation, build it. If it is plumbing every product needs (auth, payments, email), buy or borrow.

How fast does it change? If a layer changes fast (frontier AI models, deployment platforms), let someone else maintain it — buy a managed service. If it is stable (databases, web servers), borrow open-source and own the operation.

What is the cost at your scale? Below a few hundred dollars per month, buy is usually right (saves engineering time). Above a few thousand, borrow plus self-operate is usually right (engineering time amortizes). The crossover varies per category.

Applied to AI specifically: buy hosted APIs for frontier-quality, low-volume, user-facing features. Borrow open-weight models you self-host for high-volume background work. Build custom prompts, fine-tunes, and orchestration on top of both. We have ended up with this pattern across every product we ship.

Coding tools are the highest-ROI category of spend for an indie developer. The right combination 2x your shipping speed; the wrong combination costs you $40/month for marginal benefit.

Our current stack: Cursor for IDE work (~$20/month) + Claude Code for terminal and agent work (pay-as-you-go, ~$50-150/month at our usage). Total ~$70-170/month. Replaces approximately one contractor day per week of work, conservatively.

What to skip: paying for every new coding tool that launches. The market consolidated. Cursor + Claude Code + GitHub Copilot (often included with GitHub Pro for a few dollars/month) covers 95% of use cases. The remaining 5% is not worth the context-switching overhead of a fourth tool.

What changed our productivity most: not the autocomplete features, but the agent features. Claude Code's ability to read a feature request, navigate the codebase, write the implementation, run the tests, and report back is what changed how we work. We are reviewing pull requests, not typing every line.

As a solo dev, simplicity wins. Start with hosted APIs. The model providers (OpenAI, Anthropic, Google) have aggressive free tiers and generous pay-as-you-go pricing that fits prototype-scale traffic.

Pick one provider as primary and stay there. Switching costs are real — different SDKs, different prompt formats, different tool-use semantics. We use Anthropic Claude as primary because function calling is the cleanest, the model is strongest at following long instructions, and the API has fewer rate-limit surprises than alternatives.

Move to self-hosted when one specific workload hits scale. For Codmaker, that workload was content categorization in AdMetric Pro — millions of categorizations per month at $0.001 each would be $1,000/month on hosted. Self-hosted Llama 3.3 on a $300/month server does the same volume at a third the cost, and the only complexity is operating one extra server.

Avoid the trap of building a multi-model abstraction layer too early. 'What if we want to swap models' is a real concern in year three, not year one. Pick a provider, build directly against their SDK, and refactor when you have the actual problem.

AI workloads are I/O-bound and bursty. The backend choices that matter most: a language with good async support, a database that handles JSON well, a deployment platform that scales cleanly.

Our stack: Node.js with Fastify or Hono for the API layer, Postgres for the database (with pgvector for embeddings), and Railway or Fly.io for hosting. This stack handles every AI app we ship without modification.

Why not Python? Python is fine — and dominant in AI tooling. We use it for ML scripts and batch jobs. For production API servers, JavaScript wins on cold-start time, async ergonomics, and the ability to share code with our React Native and Next.js frontends. Pick whichever you know better — both work.

What we avoid: serverless functions for AI endpoints. Cold-start latency on Vercel/AWS Lambda destroys the user experience. AI APIs are slow enough already; adding 500ms-2000ms of cold-start on top is unacceptable. Use long-running containers (Railway, Fly, Render) for any AI-touching endpoint.

For web, Next.js is the default. App Router, Server Components, Server Actions, and the streaming UI primitives make it the best framework for AI-heavy apps. We use it for this site and for product companion pages.

For mobile, React Native with Expo Modules (or bare RN for native AI module work). Shared knowledge with web teams, single codebase for iOS and Android, mature ecosystem. Alternatives: Flutter is fine if you prefer Dart; native (Swift/Kotlin) if you need maximum performance and have the time. RN beats both on iteration speed for a solo dev shipping products.

AI-specific UI patterns that matter: streaming text rendering, optimistic UI for slow API calls, skeleton screens for cold starts, clear error states for API failures, and a way to cancel in-flight requests when the user navigates away.

The library that paid for itself: Vercel's AI SDK (works in Next.js and React Native via the ai-sdk-react package). Provides streaming primitives, tool use helpers, and a clean state machine for chat-style interfaces. Saved us a week of plumbing on our first AI app.

Solo developers cannot hire ops, marketing, or growth people. Workflow automation fills that gap. We run n8n self-hosted on a $20/month server, and it handles everything from analytics reports to social media posting to lead routing.

Each of the workflows below would be a part-time hire at a larger company. With n8n, they are a workflow we built once and forgot about. The combined value vs hiring is meaningful — easily $5-10k/month of work for $20/month of infrastructure.

• Daily AdMob revenue digest to Slack
• Customer support email triage with AI categorization
• Blog post distribution to Twitter/LinkedIn/RSS feeds
• App Store review monitoring with sentiment analysis
• Weekly metrics rollups (downloads, MAU, revenue) into a Notion dashboard

Distribution is the hardest problem for indie devs. AI helps in three specific ways.

Content generation. Producing the volume of blog content needed for SEO is impossible solo without AI assistance. Our process: human writes the strategic brief and edits the final, AI generates the first draft. We ship one to two long-form posts per week, none of which we could write end-to-end in the time available.

App Store optimization. AI helps with keyword research (analyzing competitor metadata at scale), screenshot generation (image models for marketing imagery), and description copywriting (testing variants quickly). PlantDoc's downloads moved meaningfully after we used AI-assisted ASO to rework the store listing [verify exact numbers].

User research at scale. We pipe App Store reviews and support emails through a sentiment-and-topic classification pipeline that produces a weekly summary of what users are saying. Manually reading every review at the volume we have now would be a part-time job; the pipeline does it in 10 minutes per week.

Concrete numbers for the stack we have described. Your numbers will differ — but the shape (small fixed infrastructure, model API costs scaling with usage) is universal.

Total: ~$820/month. Replaces approximately one full-time engineer and one part-time ops person if we did equivalent work without AI assistance. The ROI is obvious. The harder question is what you do with the time you free up — that is the part that determines whether the stack pays off.

• Coding tools: ~$100/month (Cursor + Claude Code)
• AI model APIs: ~$300/month (mix of Claude, GPT-4o, embedding APIs)
• Self-hosted AI infrastructure: ~$300/month (single A100 rental for batch work)
• Backend hosting: ~$50/month (Railway for APIs + Postgres)
• Frontend hosting: ~$0/month (Vercel free tier still works for us)
• n8n self-hosted: ~$20/month (DigitalOcean droplet)
• Miscellaneous: ~$50/month (monitoring, DNS, email, etc.)

Lesson 1: Pick a stack and stop evaluating. The marginal benefit of switching from Next.js to Remix, or from RN to Flutter, is small. The cost in lost shipping velocity is huge. Commit to a stack for two years minimum.

Lesson 2: Use AI as a multiplier, not a replacement. AI accelerates work you understand. It produces nonsense for work you do not. Build skill in the areas you want to lead; use AI to accelerate the rest.

Lesson 3: Ship early, fix in production. Solo dev ships beat polished plans every time. PlantDoc's first version had three bugs and one usability disaster in the first week. We fixed them based on real user feedback in two days. None of those issues would have been caught by another month of pre-launch testing.

Lesson 4: Measure everything. AI features have non-obvious cost curves. We track cost per active user, cost per request, conversion rate of free-to-paid, and time-to-first-meaningful-interaction. Without these numbers, you optimize the wrong things.

Common questions from solo developers evaluating this stack — or considering whether to commit to indie product building at all.

• How long does it take to learn this stack? Two to three months of consistent work to be productive across all layers, assuming prior React/Node experience. Six months to feel confident shipping production features.
• What if I am not an experienced developer? Skip the self-hosted AI layer entirely and use hosted APIs only. Skip n8n self-hosting and use the cloud tier. Complexity drops by 60% and you can still ship serious products.
• Why not use a no-code platform like Bubble? Bubble works for many use cases, especially CRUD apps. It does not work well for AI-heavy apps that need streaming, custom auth, and mobile-quality UX. Code wins for our use cases.
• Do I need to know AI/ML theory? Not really. Understand prompt engineering, basic RAG, and when to use which model. Skip the ML PhD material unless you are doing model training.
• How do I monetize an indie AI product? Same patterns as any indie product: free tier with paid upgrade, B2B subscriptions if your customer is a business, ads if your app is consumer and high-volume. Pure usage-based pricing rarely works for AI features (users hate uncertainty).

The other pieces of the indie AI stack story, written from the same builder POV.

• AI Code Completion Tools Compared 2026 — picking your coding tool: /blog/ai-code-completion-tools-compared-2026
• Self-Hosted AI: Running Llama, Mistral, DeepSeek — when to leave hosted: /blog/self-hosted-ai-llama-mistral-deepseek-2026
• React Native + AI: Production Patterns — the mobile half of the stack: /blog/react-native-ai-production-patterns-2026
• n8n Workflow Automation: Build, Scale, Self-Host — the automation layer: /blog/n8n-workflow-automation-complete-guide
• PlantDoc — our flagship indie product built with this stack: /portfolio/plantdoc