Founder Verdict
Real verdicts from 112startup founders on the tools they kept, replaced, and regret after 6–18 months in production. Each review includes the founder's company stage, MRR, and time running — so you can match recommendations to your own scale. Covers tooling decisions across hosting, databases, auth, payments, and monitoring with brutally honest advice on what worked and what didn't.
112
Founders
282
Tools kept
225
Tools replaced
Alex K.— SaaS analytics tool
$4.2k MRR14mo in prod
KEPT
Supabase — PostgreSQL underneath. Easy to extend, never hit a wall.
Vercel — Deploy preview per PR is a game-changer for solo dev.
Resend — Cheapest transactional email. React Email templates are perfect.
REPLACED
Clerk → Supabase Auth — Clerk was $95/mo at 12k MAU. Supabase Auth is free with my existing plan.
Stripe Billing Portal → Custom billing page — Portal was too rigid. Couldn't match my pricing model.
Regret: Should have started with Plausible instead of Google Analytics. Lost 3 months of privacy-compliant data.
Advice: Pick tools where the free tier covers your first 1000 users. You'll iterate faster.
Maria S.— E-commerce marketplace
$18k MRR22mo in prod
KEPT
Stripe — Connect for marketplace payouts. Nothing else comes close.
PostgreSQL (self-hosted) — Full control. RDS got expensive, moved to Hetzner.
Sentry — Caught a payment bug in prod within 2 minutes of deploy.
REPLACED
Firebase → Supabase — Firestore reads were costing $300/mo. Supabase cut it to $25.
Vercel → Coolify on Hetzner — Bandwidth bill hit $800 in one month. Self-hosting = $40/mo.
Regret: Used MongoDB for the first version. Migrating relational data to PostgreSQL took 3 weeks.
Advice: Start with PostgreSQL. Always. Even if NoSQL seems easier for your MVP.
James T.— Developer tool / CLI
$1.8k MRR8mo in prod
KEPT
Railway — Docker deploy with zero config. Perfect for backend services.
PostHog — Product analytics + feature flags in one tool. Self-hosted = free.
Typesense — Self-hosted search. Fast, simple, $5/mo on a VPS.
REPLACED
Auth0 → Clerk — Auth0 dashboard is painful. Clerk components saved weeks of UI work.
SendGrid → Resend — SendGrid deliverability was terrible. Emails hit spam constantly.
Regret: Built a custom billing system instead of using Stripe from day one. Wasted a month.
Advice: Don't build auth or billing yourself. Use a service. Your time is worth more.
Priya R.— AI writing assistant
$12k MRR11mo in prod
KEPT
Vercel — Edge functions for streaming AI responses. Low latency globally.
PlanetScale — Branching for schema changes in prod. Zero-downtime migrations.
Clerk — Organization features for team plans. Would have taken months to build.
REPLACED
Pinecone → pgvector on Supabase — Pinecone at scale = $70/mo. pgvector on existing Supabase = $0 extra.
Algolia → Meilisearch (self-hosted) — 150k records was $249/mo on Algolia. Meilisearch on $10 VPS.
Regret: Didn't set up error monitoring until month 4. Lost users to silent bugs.
Advice: Add Sentry on day one. Not day 100. You're losing users to bugs you don't know about.
Daniel M.— B2B scheduling platform
$8.5k MRR16mo in prod
KEPT
Next.js — App Router + RSC eliminated the need for a separate API layer.
Stripe — Billing portal + invoicing + tax calculation. Enterprise clients need this.
Linear — Best project management tool. Our whole team lives in it.
REPLACED
AWS (EC2 + RDS) → Railway — AWS bill was $400/mo with 50 users. Railway = $30/mo for same workload.
Datadog → Sentry + Plausible — Datadog = $200/mo minimum. Sentry ($26) + Plausible ($9) covers 90% of needs.
Regret: Over-engineered microservices from the start. A monolith would have shipped 2 months earlier.
Advice: Monolith first. Always. Split when you actually need to scale, not when you think you might.
Sophie L.— Content creation platform
$25k MRR19mo in prod
KEPT
Cloudflare R2 — Free egress. Saved $1200/mo vs S3 for user-uploaded media.
Supabase — Realtime subscriptions for collaborative editing. Just works.
PostHog — Session replay found UX issues we never would have caught otherwise.
REPLACED
Netlify → Vercel — Build times were 3x slower. Edge functions were limited.
Custom email (SES) → Resend — SES setup was a nightmare. DKIM, SPF, bounce handling — Resend handles it all.
Regret: Should have charged from day one. Free tier attracted wrong users and delayed PMF signals.
Advice: Charge money from the start. Free users give you noise, not signal.
Kevin W.— Fintech compliance dashboard
$42k MRR24mo in prod
KEPT
Stripe — ACH payouts, invoicing, and tax — tried to build custom, came crawling back.
PlanetScale — Branch-based migrations saved us from 3 potential outages during schema changes.
Linear — Only PM tool where engineers actually update tickets without being nagged.
REPLACED
Heroku → AWS ECS + Terraform — Heroku dyno limits and no VPC peering. Compliance clients need private networking.
Segment → Jitsu (self-hosted) — Segment was $12k/year. Jitsu does 80% of what we need for $0.
Regret: Didn't invest in automated testing until month 10. Manually QA'ing financial calculations nearly killed us.
Advice: If you're in fintech, write tests first. One rounding bug = regulatory nightmare + lost trust.
Lena C.— Telehealth platform
$7.2k MRR10mo in prod
KEPT
Clerk — HIPAA-ready auth with org management. Would have taken 3 months to build in-house.
Vercel — Preview deploys let clinicians test features before patients see them.
REPLACED
Twilio Video → LiveKit (self-hosted) — Twilio was $0.004/min per participant. At 2000 sessions/month it was $500+. LiveKit on a $40 VPS.
Airtable → Supabase — Airtable as a backend worked for 2 months. Then we needed real queries, RLS, and proper auth.
Regret: Used a fancy component library that looked great but had terrible accessibility. Had to rewrite forms for WCAG compliance.
Advice: In healthtech, accessibility isn't optional. Pick a11y-first components from day one — Radix, not Chakra.
Tomás G.— AI code review tool
$2.4k MRR6mo in prod
KEPT
Railway — GPU instances for inference with zero Docker headaches. Scale to zero when idle.
Sentry — LLM calls fail silently. Sentry with custom breadcrumbs catches hallucination-related errors.
Resend — Transactional emails with React components. Setup took 15 minutes.
REPLACED
OpenAI GPT-4 → Claude 3.5 Sonnet via Anthropic API — Better at code understanding, cheaper per token, more reliable structured output.
Regret: Spent 6 weeks building a custom prompt management system. Should have used Langfuse from the start.
Advice: If you're building with LLMs, instrument everything. Log every prompt, every response, every latency. You'll need it for debugging.
Aisha N.— Online course platform
$5.8k MRR13mo in prod
KEPT
Cloudflare R2 — Video hosting with free egress. Students stream 50TB/month and I pay $15.
Next.js — ISR for course pages means instant loads. Students in Africa and Asia notice the difference.
PostHog — Funnel analysis showed 60% drop-off at lesson 3. Redesigned it, retention doubled.
REPLACED
Teachable → Custom platform (Next.js + Supabase) — Teachable took 10% of revenue + $99/mo. Custom platform pays for itself after $1k MRR.
Mailchimp → Loops — Mailchimp UI is bloated and pricing doubled. Loops is built for SaaS — behavioral emails in 10 minutes.
Regret: Built my own video player instead of using Mux. Wasted 2 months on adaptive bitrate streaming.
Advice: Don't rebuild infrastructure. If Mux, Cloudflare Stream, or Bunny exists for your use case, use it.
Ryan P.— Freelancer invoicing app
$1.1k MRR5mo in prod
KEPT
Supabase — Auth, database, and storage in one. Perfect for a solo dev who doesn't want to manage 5 services.
Vercel — Free tier is genuinely enough for 500 DAU. Haven't paid a cent yet.
REPLACED
Prisma → Drizzle ORM — Prisma client was 1.8MB in my serverless bundle. Drizzle is 50kB and faster cold starts.
Tailwind UI → shadcn/ui — Tailwind UI components are copy-paste but rigid. shadcn/ui is copy-paste AND customizable.
Regret: Launched with only Google OAuth. Half my target users wanted email/password. Lost 3 weeks of signups.
Advice: Always ship email+password auth alongside OAuth. Not everyone trusts Google with their business tools.
Ingrid H.— Media monitoring dashboard
$35k MRR20mo in prod
KEPT
Clickhouse (self-hosted) — Querying 2B rows in <200ms. Nothing else at this price point comes close for analytics.
Sentry — Performance monitoring caught a memory leak that was costing us $800/mo in extra infra.
Stripe — Usage-based billing with metered events. Took an afternoon to set up.
REPLACED
Elasticsearch → Typesense — ES cluster needed a dedicated ops person. Typesense runs on a $20 VPS and handles our search load.
Redis Cloud → Dragonfly (self-hosted) — Redis Cloud was $200/mo. Dragonfly is a drop-in replacement, self-hosted for $15/mo.
Regret: Chose a trendy UI framework (Svelte) when the whole hiring pool knows React. Recruiting has been painful.
Advice: Pick boring technology for your core stack. Save the experimental stuff for internal tools where hiring doesn't matter.
Nadia F.— HR onboarding SaaS
$9.3k MRR15mo in prod
KEPT
Convex — Realtime sync across browser tabs without writing a single WebSocket line. Mutations are transactional.
Clerk — Org invites, role-based access, and SSO out of the box. Would have taken two devs a quarter to build.
Resend — Onboarding drip emails with React components. Deliverability has been flawless.
REPLACED
Supabase → Convex — Realtime listeners on Supabase kept disconnecting under load. Convex just works — no connection management.
Vercel → Fly.io — Needed long-running background jobs for PDF generation. Vercel's 10s serverless limit was a deal-breaker.
Regret: Built a custom role system before checking if Clerk Organizations covered our use case. It did. Two weeks wasted.
Advice: Read the full docs of your auth provider before building anything custom. Modern auth services cover more than you think.
Chris D.— Real estate listing aggregator
$3.1k MRR9mo in prod
KEPT
Hono — Runs on Cloudflare Workers with sub-10ms cold starts. Perfect for API routes.
Turso — Embedded replicas on the edge. Listing queries return in <5ms from any region.
Drizzle ORM — Type-safe SQL without the Prisma bloat. Migrations are plain SQL files I can actually read.
REPLACED
Next.js API routes → Hono on Workers — Needed global low-latency. Next.js on Vercel was 200ms from Australia. Workers is 12ms.
Prisma → Drizzle ORM — Prisma client was 1.8MB and cold starts were 3s on serverless. Drizzle is 50KB and starts instantly.
Regret: Scraped listings without proper rate limiting and got IP-banned from 3 data sources in the first week.
Advice: If your product depends on external data, build rate limiting and retry logic before anything else.
Elena V.— Subscription box management
$6.7k MRR12mo in prod
KEPT
Stripe — Subscriptions, proration, dunning, invoices — tried Lemon Squeezy first, came back for the flexibility.
Inngest — Durable workflows for order processing. Retries, delays, fan-out — all declarative, zero infrastructure.
Neon — Branching for staging environments. Each PR gets its own database branch automatically.
REPLACED
Lemon Squeezy → Stripe — Lemon Squeezy was great for simple payments but couldn't handle proration or usage-based billing for our add-ons.
BullMQ + Redis → Inngest — Managing Redis + queue workers was a full-time job. Inngest is serverless and handles retries automatically.
Regret: Didn't implement idempotency keys on payment webhooks. Charged a customer twice during a Stripe webhook retry storm.
Advice: Implement idempotency on day one for anything involving money. It's 20 minutes of work that prevents catastrophic bugs.
Marcus J.— Team retrospective tool
$2.9k MRR7mo in prod
KEPT
Render — Simple Docker deploys with auto-scaling. No YAML, no Kubernetes. Just push and deploy.
Supabase — Realtime for live retro boards. Multiple users see card updates instantly.
Linear — We dogfood our own tool for retros, but Linear for sprint planning. The API is chef's kiss.
REPLACED
Heroku → Render — Heroku killed the free tier and dynos were sleeping. Render's free tier actually works for side projects.
Socket.io → Supabase Realtime — Socket.io needed a dedicated server. Supabase Realtime is just a subscription on the database. Zero infra.
Regret: Built anonymous retros without any moderation. Someone posted offensive content in a demo to a potential enterprise client.
Advice: Add basic content moderation before your first enterprise demo. Even a word filter saves you from embarrassment.
Yuki T.— Developer portfolio builder
$1.5k MRR4mo in prod
KEPT
Cloudflare Pages — Free unlimited bandwidth. My users' portfolios get millions of hits and I pay $0.
tRPC — End-to-end type safety from my API to my React components. Refactoring is fearless.
Turso — SQLite at the edge. Each portfolio loads in <50ms worldwide.
REPLACED
Vercel → Cloudflare Pages — Bandwidth was $150/mo and growing linearly with users. Cloudflare Pages is free for static sites.
REST API → tRPC — Maintaining OpenAPI specs and client types manually was painful. tRPC eliminated the entire layer.
Regret: Used custom domains from day one but didn't automate SSL provisioning. Spent weekends manually issuing certs.
Advice: If your product involves custom domains, use Cloudflare for SaaS from the start. Manual SSL doesn't scale past 20 customers.
Omar B.— Logistics tracking platform
$15k MRR18mo in prod
KEPT
Fly.io — Multi-region deploys with LiteFS. Our API responds from the nearest region to each warehouse.
Trigger.dev — Background jobs for shipment status polling. Cron triggers + retries, all type-safe.
Sentry — GPS tracker integrations fail in creative ways. Sentry catches edge cases we'd never reproduce locally.
REPLACED
AWS Lambda → Fly.io — Lambda cold starts were killing our real-time tracking updates. Fly machines boot in 300ms.
Cron jobs (node-cron) → Trigger.dev — node-cron doesn't survive deploys and has no retry logic. Trigger.dev is durable and observable.
Regret: Built a custom map component instead of using Mapbox GL JS. Spent 6 weeks on pan/zoom/clustering that Mapbox does out of the box.
Advice: Don't build maps. Use Mapbox or Google Maps. Your competitive advantage is logistics logic, not cartography.
Sara K.— AI meeting summarizer
$4.8k MRR8mo in prod
KEPT
Vercel — AI SDK with streaming responses. Meeting summaries stream to the user in real time.
Neon — Serverless Postgres that scales to zero. Costs $0 when no one's using it at night.
Clerk — Google Workspace OAuth for enterprise users. SSO setup took 30 minutes, not 3 weeks.
REPLACED
Whisper API (OpenAI) → Deepgram — Whisper was $0.006/min. At 50k minutes/month, Deepgram's pay-as-you-go was 40% cheaper with better accuracy.
MongoDB → Neon (Postgres) — Needed full-text search on meeting transcripts. Postgres tsvector + GIN index outperformed Mongo text search.
Regret: Stored full audio files in the database instead of object storage. Hit Neon's storage limit in month 2.
Advice: Audio and video go in S3/R2, metadata goes in your database. Seems obvious but you'll forget under deadline pressure.
Ben A.— API rate limiting SaaS
$3.4k MRR10mo in prod
KEPT
Hono — Runs on Cloudflare Workers. Our middleware is literally the product — low latency matters.
Upstash Redis — Serverless Redis with per-request billing. Sliding window counters in 5 lines of code.
Drizzle ORM — Type-safe queries with zero overhead. Migrations are SQL files I can actually review.
REPLACED
Express.js → Hono on Cloudflare Workers — Express on a VPS was $20/mo at rest. Workers scale to zero and respond in <10ms globally.
Upstash QStash → Trigger.dev — QStash was fine for simple queues but Trigger.dev's retry UI and observability saved hours of debugging.
Regret: Priced per request from the start. Should have priced per project — way easier to sell to teams.
Advice: Think about your billing model before you write a single line of code. Switching pricing models mid-flight is painful.
Fatima Z.— Legal document SaaS
$11k MRR17mo in prod
KEPT
Payload CMS — Type-safe CMS with Postgres backend. Replaced a custom admin panel that took 3 months to build.
Clerk — Organization roles mapped directly to our firm/member permission model. Zero custom code.
Sentry — PDF generation fails in production in ways it never does locally. Sentry with context is the only way to catch it.
REPLACED
Contentful → Payload CMS — Contentful was $300/mo for our content volume. Payload self-hosted on Railway = $15/mo.
pdf-lib → Puppeteer on Fly.io — pdf-lib couldn't handle complex legal templates. Puppeteer renders HTML to PDF — templates are just React components.
Regret: Didn't build an audit trail from day one. Law firms need to know who touched what document and when. Retrofitting was brutal.
Advice: If you're selling to regulated industries, build your audit log before your first enterprise call. Not after.
Leo H.— Open source billing SDK
$2.1k MRR9mo in prod
KEPT
Bun — Our test suite went from 18s to 3s. TypeScript transpilation is free. I'm not going back to Node.
Biome — Replaced ESLint + Prettier in one config file. Lint runs in 80ms across the entire codebase.
tRPC — The demo app and SDK share types end-to-end. Zero type drift between client examples and docs.
REPLACED
Jest → Bun test — Jest with ts-jest was slow and fragile. Bun test runs natively and supports TypeScript out of the box.
ESLint + Prettier → Biome — Two configs, two tools, constant version conflicts. Biome is one tool, one config, one install.
Regret: Published v1 with a breaking API change in v1.1. Didn't think about semver or changelogs until users complained in GitHub issues.
Advice: Treat your public API like a contract from v0.1. Semver isn't bureaucracy — it's communication.
Camille R.— Design system analytics
$6.2k MRR11mo in prod
KEPT
PostHog — Event autocapture tracked component usage across 50 client apps. Found our most-used components instantly.
Turborepo — Monorepo with 6 packages. Caching reduced CI from 12 minutes to 90 seconds.
Radix UI — Accessible primitives. Our enterprise clients need WCAG 2.1 AA — Radix handles it out of the box.
REPLACED
Lerna → Turborepo — Lerna was slow and the remote cache setup was painful. Turborepo's Vercel-hosted cache works in 5 minutes.
Storybook → Histoire (Vite) — Storybook cold start was 40s. Histoire started in 3s and supports Vue and Svelte too.
Regret: Charged by seats instead of by API calls. Small teams underused the product and churned. Usage-based would have aligned incentives.
Advice: Price on the value metric that scales with your customer's success, not their headcount.
Jake S.— Uptime monitoring tool
$7.8k MRR14mo in prod
KEPT
Fly.io — Multi-region ping checks from 8 regions. LiteFS replicates SQLite to each checker node.
Axiom — Ingesting 50M+ check results per month for $25. ClickHouse would have cost 10x to manage.
Resend — Incident alert emails land in inbox every time. Deliverability has never been an issue.
REPLACED
Grafana Cloud → Axiom — Grafana Cloud's metrics pricing scaled badly. Axiom's log-based approach at flat rate is more predictable.
PagerDuty → Custom alerting via Resend + Slack webhook — PagerDuty was $21/user/month. Custom alerts with escalation logic took 2 hours and cost $0.
Regret: Launched with only email alerts. Users wanted Slack, PagerDuty, and webhooks from day one. Lost 8 trials that month.
Advice: Launch with webhook support at minimum. Every enterprise tool has a webhook endpoint. One integration covers everything.
Nina P.— AI image generator for e-commerce
$5.1k MRR7mo in prod
KEPT
Replicate — Run SDXL and ControlNet without managing GPU infra. Pay per second of compute.
Cloudflare R2 — Generated images are large. Free egress means I don't pay to serve them to users.
Neon — Branching let me safely test schema changes for new model outputs without risking prod data.
REPLACED
AWS SageMaker → Replicate — SageMaker setup took 2 weeks and cost $800/mo at idle. Replicate is pay-per-run and scales to zero.
Vercel Blob → Cloudflare R2 — Vercel Blob egress fees added up fast with image-heavy workloads. R2 free egress is a real differentiator.
Regret: Didn't watermark generated images in beta. Some users resold beta outputs without attribution. Set expectations early.
Advice: If your product generates IP, define your ToS and watermark strategy before public launch. Beta doesn't mean consequence-free.
David L.— Open-source headless CMS
$4.5k MRR20mo in prod
KEPT
Astro — Docs site generates 800 static pages in 4 seconds. Content collections fit our schema perfectly.
Drizzle ORM — Multiple DB adapters (SQLite, Postgres, MySQL) from one schema definition. Perfect for a multi-DB CMS.
Zod — Content schema validation at the edge. Catches malformed content before it corrupts the database.
REPLACED
Docusaurus → Astro — Docusaurus was slow to build and React-only. Astro gave us MDX, faster builds, and framework-agnostic components.
TypeORM → Drizzle ORM — TypeORM decorators were a mess with TypeScript strict mode. Drizzle's schema-as-code is much cleaner.
Regret: Didn't set up sponsorship infrastructure until month 12. Left 8 months of GitHub Sponsors revenue on the table.
Advice: Add GitHub Sponsors and Open Collective to your README on day one. Even $50/month validates that people value your work.
Mia C.— B2B invoice automation
$38k MRR26mo in prod
KEPT
Effect — Complex financial pipelines need explicit error handling. Effect's typed errors caught 3 categories of bugs before prod.
Linear — API lets us sync customer bug reports directly to Linear issues. Engineers see real user context.
Stripe — Smart Retries on failed invoices recovered 18% of churned revenue automatically. Worth every cent of fees.
REPLACED
tRPC → Hono + Zod — tRPC was too coupled to React. We added a mobile app — Hono works for both React and React Native clients.
Papertrail → Axiom — Papertrail's 30-day retention was killing us during audits. Axiom's long retention at lower cost was a clear win.
Regret: Didn't implement a proper multi-tenant data isolation model early enough. Backfilling RLS policies on 2M rows was a 4-day ordeal.
Advice: Row-level security is not an optimization — it's a foundation. Enable it before you have any data in production.
Raj M.— Developer API gateway
$14k MRR15mo in prod
KEPT
Hono — Type-safe middleware with sub-millisecond overhead. Our product IS the API layer — every ms counts.
Upstash Redis — Rate limiting state without running Redis servers. Serverless billing matches our unpredictable traffic.
Zod — Input validation on every route. Found 12 integration bugs in the first week from clients sending wrong types.
REPLACED
Kong Gateway → Custom Hono middleware — Kong was $500/mo and required a DBA for the Postgres backend. Our own middleware is 200 lines and free.
Logtail → Axiom — Axiom's APL query language is vastly more powerful. Found a P95 latency regression in 10 minutes that Logtail couldn't surface.
Regret: Launched with only REST. Added GraphQL in month 6 and had to maintain two separate auth middleware stacks for 4 months.
Advice: Pick your API contract style before launch. Adding a second style later means double the maintenance forever.
Amy T.— SaaS localization platform
$9.1k MRR13mo in prod
KEPT
Payload CMS — Content modeling for translation workflows with custom fields. No other headless CMS let us shape the data this way.
Convex — Realtime sync for translator collaboration. Two translators working on the same string see each other's changes instantly.
Mantine — RTL support out of the box. Our platform needs to work in Arabic and Hebrew — Mantine handles direction automatically.
REPLACED
Airtable → Payload CMS + Postgres — Airtable API rate limits were killing our import pipeline. Payload gave us raw SQL performance.
Socket.io → Convex — Managing WebSocket servers with Socket.io at scale was a full-time ops job. Convex eliminated the infrastructure entirely.
Regret: Didn't hire a native speaker for each language to QA the product. Found embarrassing RTL layout bugs 6 months in.
Advice: If you're building for international markets, test every feature in RTL and CJK locales before launch. Not after.
Sam W.— Git analytics for engineering teams
$16k MRR18mo in prod
KEPT
Neon — Branching for each customer's data isolation experiment. Spin up a branch, test, merge or discard.
Turborepo — Frontend, API, and data pipeline in one repo. Remote cache on CI cut our build time from 9 minutes to 2.
PostHog — Feature flags let us ship half-finished features to internal users. No separate flag service needed.
REPLACED
Mixpanel → PostHog — Mixpanel at our event volume was $800/mo. PostHog self-hosted is free and adds session replay.
dbt Cloud → Custom Drizzle migrations + cron — dbt Cloud was $100/mo for a pipeline we could express in 50 lines of TypeScript.
Regret: Gave free access to GitHub-connected repos without rate limiting the sync. One customer with a 50k-commit monorepo brought down the API for everyone.
Advice: Put hard limits on data ingestion per customer from day one. One whale can sink your infra without them even trying.
Hana B.— Newsletter monetization platform
$3.7k MRR8mo in prod
KEPT
Resend — React Email templates. Newsletters look identical in Gmail, Outlook, and Apple Mail — first time ever.
Stripe — Subscription management with smart dunning. Recovered 22% of failed payments automatically.
Vercel — Edge middleware for subscriber gating. No server round-trip to check if a user can read a post.
REPLACED
ConvertKit → Custom Resend + Supabase — ConvertKit took 5% of paid subscriber revenue. Building our own stack cost 3 weeks but saved $800/mo.
Gumroad → Stripe — Gumroad's 10% fee on digital products adds up fast. Stripe's 2.9% + 30¢ is dramatically cheaper at scale.
Regret: Didn't set up email authentication (DMARC/DKIM/SPF) properly at launch. Half our newsletters went to spam for the first 3 weeks.
Advice: Do your DNS homework before sending a single newsletter. SPF, DKIM, and DMARC take 2 hours but save your sender reputation.
Patrick O.— Internal tool builder
$2.2k MRR6mo in prod
KEPT
Payload CMS — Admin panels are just collections with custom views. Saved 2 months of building CRUD interfaces.
Hono — API layer runs on Cloudflare Workers. Sub-10ms globally, $0 at our traffic level.
Drizzle ORM — Schema-as-code with migrations I can version. No magic, no surprises.
REPLACED
Retool → Custom stack (Next.js + Payload) — Retool was $10/user/month. Our clients have 20-50 users. $500+/mo before we'd shipped anything.
Supabase → Neon + Drizzle — Supabase's Realtime was overkill. Neon with direct Postgres gave us full control and half the cost.
Regret: Sold annual contracts to early customers before the product was stable. Had to honor refunds twice during major rewrites.
Advice: Monthly billing until you've had 6 stable months in production. Annual contracts lock in customers who'll demand refunds when things break.
Zara A.— Podcast transcription and search
$4.1k MRR9mo in prod
KEPT
Deepgram — Speaker diarization is 95% accurate out of the box. Whisper hallucinated on crosstalk.
pgvector on Supabase — Semantic search over transcripts without a separate vector database. Single Postgres instance handles both.
Cloudflare R2 — Storing 20TB of audio files. Free egress means I'm not paying to stream files back to users.
REPLACED
Pinecone → pgvector on Supabase — Pinecone at 2M vectors was $70/mo. pgvector on my existing Supabase plan is $0 extra.
Algolia → Meilisearch (self-hosted) — Algolia was $149/mo for my record count. Meilisearch on a $12 VPS and search is fast.
Regret: Didn't batch transcription jobs. Sent 500 simultaneous API calls during an import feature launch. Got rate-limited and billed for retries.
Advice: Any API you call at volume needs a queue in front of it. Inngest or BullMQ. Never call external APIs directly from user actions.
Carlos F.— Event ticketing SaaS
$8.3k MRR12mo in prod
KEPT
Stripe — Payment Link for quick event setup. Ticket sales flowing in 20 minutes with zero code.
Inngest — Durable event confirmation emails with scheduled reminders 24h before each event.
PostHog — Conversion funnel showed 40% drop-off on the seating chart step. Redesigned it, conversions doubled.
REPLACED
Eventbrite API → Custom platform — Eventbrite's 6% fee + 2.5% service fee was eating our margin. Custom platform pays for itself at $5k GMV/month.
Amazon SES → Resend — SES bounce handling required Lambda + SNS + SQS. Resend handles it with a single webhook.
Regret: Launched without a waitlist feature. A popular local event sold out in 2 minutes and we had nowhere to capture the overflow demand.
Advice: Build a waitlist before you think you need one. Sold-out events are marketing gold — don't waste the demand signal.
Luca M.— Code snippet sharing tool
$1.3k MRR5mo in prod
KEPT
Cloudflare Pages — Free static hosting with unlimited bandwidth. My users share snippets publicly — spiky traffic, zero cost.
Bun — SQLite bundled in. My hobby side of this runs SQLite on Bun with zero infrastructure.
Biome — Formats and lints in one pass. CI went from 45s to 8s just by switching from ESLint + Prettier.
REPLACED
Vercel → Cloudflare Pages — Vercel's bandwidth limit hit during a Hacker News front page moment. Pages has no limits.
highlight.js → Shiki — highlight.js themes looked dated and didn't support latest language features. Shiki uses VS Code grammars — perfect highlighting.
Regret: Didn't add syntax highlighting server-side from day one. Clients rendering highlight.js caused layout shift on every page load.
Advice: Render syntax highlighting at build time or on the server. Client-side highlight causes flash of unstyled code that destroys the experience.
Erin T.— SaaS product analytics SDK
$10.5k MRR16mo in prod
KEPT
Effect — Our SDK processes event streams with complex error handling. Effect's typed errors make impossible states actually impossible.
Turborepo — SDK, docs, and dashboard in one repo. Build caching means contributors don't wait 5 minutes to run tests.
Biome — Our SDK ships zero-dependency TypeScript. Biome enforces consistent style without adding to deps.
REPLACED
Segment → PostHog (self-hosted) — We were spending $800/mo on Segment to analyze our own analytics product. PostHog self-hosted is free.
Rollup → tsup — Rollup config was 200 lines to handle ESM + CJS + type declarations. tsup does it in 10 lines.
Regret: Published types that leaked internal implementation details in v1. Breaking change in v1.1 to fix it caused a support week.
Advice: Use @internal JSDoc tags and barrel exports from day one. Your public types are a contract — the smaller the surface, the easier to maintain.
Jordan K.— Video lesson platform for kids
$12k MRR14mo in prod
KEPT
Mux — Adaptive bitrate streaming for kids on school Chromebooks with 2Mbps connections. Just works.
Clerk — Parent + child account model with org features. Would have taken months to build the permission model.
Sentry — Kids' devices are unpredictable — old iPads, school proxies. Sentry captures errors we'd never reproduce in the office.
REPLACED
Vimeo → Mux — Vimeo couldn't stream at low bitrates without quality degrading. Mux's per-minute pricing is cheaper at our volume.
Firebase → Supabase + Clerk — Firebase Auth + Firestore + Storage was 3 SDKs and 3 bills. Supabase covered everything in one.
Regret: Forgot to add COPPA compliance before launching in the US. Had to pause US signups for 6 weeks while legal caught up.
Advice: If your product touches children, read COPPA, GDPR-K, and your state equivalents before writing a single line of code.
Mei L.— SaaS accessibility auditor
$3.8k MRR10mo in prod
KEPT
Playwright — Runs real browser accessibility audits with axe-core integration. Can't fake a11y issues with unit tests.
Radix UI — Our own app has to be accessible. Radix primitives are keyboard-navigable and screen-reader-tested out of the box.
Linear — API integration lets our tool auto-create Linear issues from audit findings with full context.
REPLACED
Puppeteer → Playwright — Puppeteer's Chrome-only limitation meant we couldn't audit Safari-specific WCAG failures. Playwright covers all three major engines.
GitHub Issues → Linear — GitHub Issues had no programmatic priority or estimation. Linear's API is far richer for creating structured bug reports.
Regret: Built the report export as PDF-only. Every enterprise customer asked for CSV or JIRA export in the first week.
Advice: Always ship at least two export formats. PDF is for humans, CSV/JSON is for the other tools they're already using.
Andre S.— SaaS translation management
$22k MRR20mo in prod
KEPT
Convex — Translators in 12 timezones collaborating on the same strings in real time. Convex mutations are transactional — no conflicts.
Sentry — Our API is called from CI pipelines. Sentry's release tracking correlates deploy time with error spikes perfectly.
Stripe — Per-string billing with usage metering. Stripe's metered subscriptions handled our pricing model without custom code.
REPLACED
Firebase Realtime DB → Convex — Firebase's security rules were impossible to express our complex org/project permission model in. Convex mutations are TypeScript — much easier.
Heroku → Railway — Heroku's price/performance ratio deteriorated post-free-tier. Railway gave us the same DX for 60% less cost.
Regret: Used ISO language codes inconsistently across the database. Half the table used 'en', half used 'en-US'. Normalizing 1M rows mid-growth was painful.
Advice: Pick your locale format on day one and enforce it at the schema level. A check constraint costs nothing; a data migration costs weeks.
Tom H.— SaaS password manager for teams
$5.5k MRR11mo in prod
KEPT
Supabase — Row-level security is the product — team members can only see secrets their org owns. Postgres RLS is the exact right abstraction.
Resend — Invitation emails with signed tokens. Resend's delivery rate means invites don't get lost in spam.
Cloudflare Workers — Key derivation runs at the edge. Latency would kill the UX if it hit a central server.
REPLACED
AWS KMS → Cloudflare Workers Secrets — KMS was $0.03/API call and required SDK bloat. Workers Secrets are free and available in 300 PoPs.
JWT (stateless) → Lucia (session-based auth) — JWTs can't be revoked without a deny-list. In a password manager, instant revocation is non-negotiable.
Regret: Skipped a security audit for the first 8 months because it seemed expensive. A customer pointed out a client-side encryption flaw that had been there since launch.
Advice: Budget for a security review in month 3, not month 18. In security products, the cost of a breach is your entire business.
Isabel R.— AI resume builder
$6.9k MRR11mo in prod
KEPT
Vercel — Streaming Claude responses to the browser via RSC. Users see resume content appearing in real time.
Neon — Branching for A/B testing different resume scoring algorithms without touching prod data.
PostHog — Heatmaps on the resume editor showed users ignoring the 'tone' slider entirely. Removed it, onboarding improved.
REPLACED
OpenAI GPT-4o → Claude 3.5 Sonnet — Claude follows formatting instructions more reliably. Resume bullet points came out properly structured without prompt hacks.
Puppeteer → React-PDF — Puppeteer for PDF generation required a server and 400MB Docker image. React-PDF runs client-side in 80KB.
Regret: Made resume exports free during beta. Switching to paid exports caused a 40% refund request rate from beta users who expected it free forever.
Advice: Never offer a premium feature for free, even in beta. Set the expectation from day one — 'beta access' means the product, not the pricing.
Kim J.— SaaS expense tracker for freelancers
$2.6k MRR7mo in prod
KEPT
Supabase — Postgres RLS for multi-user account sharing. Partners can see each other's expenses without me writing a single auth check.
Resend — Monthly expense digest emails with inline charts. React Email makes it trivial to embed charts as static images.
Plausible — Privacy-first analytics. My users are freelancers who hate surveillance capitalism. No cookie banner needed.
REPLACED
Google Sheets API → Supabase — Sheets as a database broke at 5000 rows and had terrible concurrency. Supabase is what I should have started with.
Chart.js → Recharts — Chart.js doesn't support React's rendering model. Recharts components compose naturally with state — no imperative destroy/rebuild.
Regret: Built a mobile app in month 3 before the web app had PMF. Mobile doubled my support surface area for features users weren't even using on desktop.
Advice: Nail the web app first. Mobile should be a reward for product-market fit, not a distraction during it.
Olivia N.— SaaS social media scheduler
$13k MRR17mo in prod
KEPT
Inngest — Scheduled post publishing with per-user cron schedules. Inngest handles 50k daily triggers without any infrastructure.
Cloudflare Images — Auto-resize images for each platform's aspect ratio requirements. No ffmpeg servers, no S3 + Lambda pipeline.
Clerk — LinkedIn and Twitter OAuth in the same flow. Clerk's multi-provider support saved a week of OAuth hell.
REPLACED
BullMQ → Inngest — BullMQ required a Redis server and a worker process that kept dying in production. Inngest is serverless and has a great UI for debugging failed jobs.
Sharp (self-hosted) → Cloudflare Images — Running Sharp on a VPS to resize images was $30/mo and 200ms latency. Cloudflare Images is faster and cheaper at scale.
Regret: Didn't implement social platform API rate limit tracking. Got all users throttled when a viral campaign pushed concurrent API calls to 200/second.
Advice: Track your third-party API quota usage in a dashboard. When you hit 80%, get an alert. Don't wait for the provider to cut you off.
Noah R.— B2B email outreach tool
$19k MRR21mo in prod
KEPT
Resend — Deliverability on cold outreach is everything. Resend with dedicated IPs never hit spam folders in my internal tests.
Tinybird — Open/click/bounce tracking at 100M events/month for $200. ClickHouse-backed, query results in milliseconds.
Linear — Customer feature requests go straight to Linear via Zapier. Engineers see real user language, not filtered PM summaries.
REPLACED
Amplitude → Tinybird + Metabase — Amplitude was $1800/mo at our event volume. Tinybird + a cheap Metabase instance covers everything for $250/mo.
Redis (self-hosted) → Upstash Redis — Managing a Redis cluster for rate limiting and session caching was 2 hours of ops per week. Upstash is zero ops.
Regret: Let customers use shared sending domains in beta. When one user sent spam, all users on that domain got blocklisted together.
Advice: Dedicated sending domains per customer from day one. Shared infrastructure in email is a liability waiting to explode.
Hugo D.— Pre-revenue indie dev forum
$0 MRR3mo in prod
KEPT
Cloudflare Pages — Free static + Workers Functions for the API. Zero cost while I figure out if anyone wants this.
Turso — 9GB free tier is generous for a forum MVP. SQLite at the edge means search feels instant.
Better Auth — Self-hosted auth with no SaaS dependency. I don't want a $25/mo bill before my first paying user.
REPLACED
Supabase → Turso + Better Auth — Supabase free tier pauses after a week of inactivity. Killer for a pre-launch project I work on weekends.
Vercel → Cloudflare Pages — Vercel free tier started showing usage warnings during a Twitter spike. Cloudflare has no bandwidth meter.
Regret: Spent two months perfecting the editor before showing anyone. Should have launched with a Notion-shared page and a Stripe Payment Link.
Advice: Pre-revenue means free tiers everywhere. Every paid SaaS is a tax on motivation when you have no signal yet.
Yara M.— Side-project habit tracker
$420 MRR4mo in prod
KEPT
Supabase — Free tier covers my 600 users. Auth, database, and storage in one — perfect for nights-and-weekends scope.
Resend — 3000 emails/month free is enough for daily streak reminders. Setup took 15 minutes including DNS.
REPLACED
Firebase Auth → Supabase Auth — Firebase phone auth was $0.06/SMS. At 200 verifications/month I switched to Supabase email magic links — free.
Vercel → Cloudflare Pages — Got a Vercel usage alert at 90 GB bandwidth. Pages has no limit and the deploy DX is comparable now.
Regret: Charged $4/mo when I should have charged $9. Lower price didn't increase conversion — it just left money on the table.
Advice: Anchor your price 2x higher than feels comfortable. Indie users churn on $4 just as easily as $9, and the math at $9 actually works.
Diego A.— AI cover letter generator
$2.7k MRR6mo in prod
KEPT
Anthropic API — Claude 3.5 Sonnet writes cover letters that don't sound AI-generated. Users pay specifically for that quality.
Stripe — Payment Links + webhook handler. Took an afternoon to ship paid plans. Smart Retries recovered $180 in failed payments last month.
Cloudflare R2 — Storing user resume PDFs. Free egress and the S3 API works with every SDK.
REPLACED
OpenAI GPT-4o → Claude 3.5 Sonnet — Cover letter quality on Claude was noticeably better. Per-token cost is comparable but I needed fewer retries to get usable output.
AWS S3 → Cloudflare R2 — S3 egress fees were creeping toward $40/mo as user count grew. R2 is $0 egress at the same storage price.
Regret: Didn't add a usage limit on the free tier for the first month. One user generated 800 cover letters in a day and burned through $90 of API credit.
Advice: Rate-limit the free tier on day one. Even if you trust your users, one buggy script can drain your monthly LLM budget overnight.
Karim H.— Stripe-connected marketplace for local services
$5.4k MRR9mo in prod
KEPT
Stripe Connect — Express accounts with onboarding hosted by Stripe. KYC and tax handled — I would have needed a lawyer to build this.
Inngest — Reconciliation jobs that run after every Connect transfer. Idempotent retries make the financial logic safe.
Supabase — RLS for buyer/seller data isolation. Each role only queries what their auth claim allows. Zero custom checks in app code.
REPLACED
PayPal → Stripe Connect — PayPal's marketplace API was undocumented chaos. Stripe Connect docs are exhaustive and the Express flow converted 2x better at onboarding.
node-cron → Inngest — node-cron lost jobs across deploys and had no observability. Inngest gives me a dashboard for every workflow.
Regret: Took 5% platform fees from day one without disclosing the breakdown to sellers. A few power sellers spreadsheeted it and felt misled.
Advice: Show a clear fee breakdown on every transaction. Hidden margins in marketplaces erode trust faster than any feature can rebuild it.
Astrid V.— Self-serve API documentation tool
$3.9k MRR11mo in prod
KEPT
Cloudflare Workers — Docs render at the edge in <40ms globally. Customer's API docs feel native to their brand.
Drizzle ORM — Schema-first, type-safe queries. I read every SQL statement my code generates.
Hono — Tiny middleware footprint on Workers. The same Hono router handles 8 customer subdomains in one Worker.
REPLACED
Prisma → Drizzle ORM — Prisma's query engine binary doesn't run on Cloudflare Workers. Drizzle works natively with the D1 driver.
Express → Hono — Express on a VPS was $20/mo. Hono on Workers free tier handles all my traffic at sub-10ms.
Regret: Built custom theming with inline styles for the first version. Migrating 40 customer docs to a token-based system took a week of careful migration scripts.
Advice: If you let customers customize anything visually, ship CSS variables and design tokens from day one. Inline styles are a one-way door.
Luna P.— AI-powered CRM for solo founders
$28k MRR19mo in prod
KEPT
Vercel AI SDK — Streaming RSC components with structured outputs. Users see contact summaries appear live as Claude analyzes their inbox.
Neon — Per-tenant branching for enterprise customers. Each big client gets isolated data without spinning up new clusters.
Stripe — Usage-based billing on AI token spend with metered subscriptions. Stripe handles the meter aggregation perfectly.
REPLACED
MongoDB Atlas → Neon — Mongo's $400/mo cluster underutilized 80% of the time. Neon scales compute to zero — same workload now $50/mo.
Pinecone → pgvector on Neon — Pinecone added another bill and another point of failure. pgvector on Neon means one DB, one connection string, one less SaaS.
Regret: Stored Anthropic API keys in plaintext for the first 3 months because 'we'd encrypt later.' Later turned into a compliance fire-drill before our first enterprise customer.
Advice: Encrypt customer-provided secrets in the DB from commit one. AES-256 with KMS is 30 lines of code. Skipping it costs weeks.
Reuben K.— Open-source feature flag SDK
$1.6k MRR8mo in prod
KEPT
Bun — Test suite runs in 1.8s vs 14s on Node + Jest. Faster feedback loop changed how I write tests.
tsup — ESM + CJS + .d.ts in one config file. Replaced 200 lines of Rollup config with 8.
Biome — Single binary, no plugin ecosystem to wrangle. CI lint step dropped from 30s to 1.2s.
REPLACED
LaunchDarkly → Self-hosted alternative (own SDK) — I built this because LaunchDarkly was $400/mo for the smallest team plan. My OSS SDK + a $5 VPS does the same job for me.
npm → Bun — npm install was 90s on a fresh clone. bun install is 4s. Compounds across every CI run and teammate onboarding.
Regret: Released v1 without a JSON Schema for flag config files. Every customer's YAML drifted in subtly different ways. Schema after the fact is migration hell.
Advice: Validate config files with a published schema from v0.1. Drift in user-facing config is the worst kind — they blame your library, not their typo.
Tatiana O.— Webhook debugging dashboard
$6.8k MRR13mo in prod
KEPT
Hono on Cloudflare Workers — Webhook receiver runs at the edge — sub-50ms response globally. Customers' webhook timeouts dropped.
Upstash Redis — Per-customer rate limiting with sliding windows. Serverless billing matches our spiky webhook traffic.
Axiom — Stores 200M webhook events/month for $30. APL queries find the one bad payload from a customer in seconds.
REPLACED
Heroku → Cloudflare Workers — Heroku dynos cost $200/mo and added 80ms of latency vs Workers at the edge. Workers free tier covered most of my traffic.
Postgres (logs table) → Axiom — Logs table grew 50GB/month and queries got slow. Axiom is purpose-built for this — Postgres for relational data only now.
Regret: Built without webhook signature verification on my own ingestion endpoint for 4 months. A customer pointed it out before any abuse, but the audit was embarrassing.
Advice: Sign and verify every webhook you receive AND every webhook you send. Both directions, from day one.
Pavel S.— B2B billing analytics dashboard
$52k MRR24mo in prod
KEPT
Stripe — Direct API access to subscription events for our customers. Stripe's webhook reliability is what makes this product possible.
Tinybird — Aggregating MRR/churn over 5B events. Real-time dashboards refresh in <100ms.
Clerk — Organizations + SSO + SAML. Enterprise customers wanted Okta integration on day one — Clerk shipped it without custom work.
REPLACED
ClickHouse (self-hosted) → Tinybird — Managing ClickHouse on EKS was 8h/week of ops. Tinybird is managed ClickHouse with a published API layer — zero ops.
Auth0 → Clerk — Auth0 SAML setup was a 2-week saga per customer. Clerk's UI lets enterprise admins self-serve their IdP setup.
Regret: Used integer cents in some columns and decimal dollars in others. Reconciliation bugs took 3 engineers 2 weeks to fully eradicate.
Advice: Pick ONE money representation across your entire codebase — minor units (cents) as bigint. Document it in your README. Enforce it in code review.
Sasha V.— AI startup knowledge base
$3.6k MRR7mo in prod
KEPT
OpenAI Embeddings — text-embedding-3-small at $0.00002/1k tokens. Ingesting our customers' docs at almost zero cost.
Supabase — pgvector + Postgres in one place. Semantic search over customer docs alongside relational metadata — no extra service.
Vercel — AI SDK streaming for the chat interface. Users see the answer appear word-by-word, latency feels invisible.
REPLACED
Weaviate → pgvector on Supabase — Weaviate self-hosted needed 2GB RAM minimum and a dedicated VM. pgvector runs on my existing Supabase instance.
LangChain → Vercel AI SDK + custom pipeline — LangChain abstracted everything until I had a bug I couldn't find. Replaced it with 80 lines of plain TypeScript I actually understand.
Regret: Stored embeddings for the full document instead of chunking first. Retrieval quality was terrible until month 3 when I rewrote the ingestion pipeline.
Advice: Chunk before you embed. 512 tokens with 10% overlap is the starting point. Getting this wrong means your RAG answers are just noise.
Brendan O.— Fintech spend analytics for SMBs
$11k MRR14mo in prod
KEPT
Neon — Schema branching per environment. Every engineer has their own Postgres that mirrors prod — no more 'works on my machine'.
Hono — Type-safe API routes on Cloudflare Workers. Bank data endpoints need to be fast and this stack delivers 8ms p99.
Stripe — Financial Connections for read-only bank account access. KYC burden dropped dramatically — Stripe handles the regulatory surface.
REPLACED
Plaid → Stripe Financial Connections — Plaid was $500/mo for our connection volume. Stripe Financial Connections is free with Stripe Payments, which we already used.
AWS Aurora → Neon — Aurora minimum instance was $180/mo even at near-zero load. Neon's scale-to-zero brought it down to $19/mo.
Regret: Didn't enforce PII data residency from the start. One EU enterprise customer asked which region their data lived in and we couldn't answer for 3 weeks.
Advice: Know exactly which region every byte of customer PII lives in before your first enterprise call. They will ask, and 'we'll check' is not acceptable.
Florence K.— Sanity-powered content ops platform
$8.1k MRR15mo in prod
KEPT
Sanity — GROQ queries beat GraphQL for content-heavy apps. Portable Text handles rich content that no other CMS handles as cleanly.
Next.js — ISR with on-demand revalidation via Sanity webhooks. Content editors hit publish and pages update in under 2 seconds globally.
Cloudflare — CDN in front of Vercel cut origin requests by 90%. Cost dropped from $200/mo to $40/mo under the same traffic.
REPLACED
Contentful → Sanity — Contentful's rigid content model didn't fit our clients' editorial workflows. Sanity's schema-as-code let us model exactly what each client needs.
Algolia → Sanity's built-in search — Algolia was $149/mo and required a sync pipeline. Sanity's native search handles our content volume for free.
Regret: Let every client customize their Sanity schema with no governance. After 12 clients, we had 12 completely different codebases under one SaaS umbrella.
Advice: Define a locked base schema and let clients extend it, not replace it. Schema divergence across tenants is a maintenance nightmare that compounds every month.
Marcus B.— Polar-powered OSS monetization tool
$1.9k MRR6mo in prod
KEPT
Polar — Benefits API for GitHub Sponsors-style perks. Issue funding and one-time donations in one SDK — nothing else does this.
GitHub Actions — CI pipeline triggers on every PR. Tests, type-check, and publish in 90 seconds.
Railway — Deploy from GitHub with zero config. Postgres and the API service on one $5 plan.
REPLACED
Gumroad → Polar — Gumroad's 10% fee hurt. Polar's 5% for open-source projects plus the GitHub integration is exactly right for my users.
Fly.io → Railway — Fly's CLI is powerful but the mental overhead of Machines API was too high for a side project. Railway just deploys.
Regret: Didn't set up a changelog before reaching 200 GitHub stars. Early adopters had no idea features they'd asked for had shipped.
Advice: Create a CHANGELOG.md and post in GitHub Releases from your first stable version. Momentum is built on visible progress.
Chloe W.— Micro-SaaS link-in-bio for creators
$2.3k MRR5mo in prod
KEPT
Cloudflare Pages — Creator pages get shared in viral posts. One TikTok embed drove 800k hits in a day — zero bill, zero incident.
Turso — Per-database isolation per creator. SQLite branches for each user and the 9GB free tier covers my first thousand creators.
Stripe — Payment Links for creator tip jars. No-code checkout took 20 minutes to ship.
REPLACED
Supabase → Turso — Supabase pauses free databases after inactivity. Creator profiles need to be fast at any hour — Turso's edge replicas solved it.
Lemon Squeezy → Stripe — Lemon Squeezy's dashboard was confusing for creators setting up their own tip jars. Stripe's Payment Links are self-explanatory.
Regret: Allowed custom CSS from day one without sanitizing it. One creator injected a keylogger script that ran on their visitors' browsers for 48 hours before I caught it.
Advice: Custom CSS must run in a sandboxed iframe or be heavily sanitized. Never trust user-supplied styles in your origin. This isn't optional.
Antoine L.— Developer changelog widget SaaS
$4.7k MRR10mo in prod
KEPT
Cloudflare Workers — The widget script loads from Workers. Sub-20ms globally means no impact on customers' Core Web Vitals scores.
Drizzle ORM — D1 SQLite adapter works natively on Workers. The whole stack runs at the edge without a separate origin server.
Resend — Weekly changelog digest emails to subscribers. React Email templates look professional in every client.
REPLACED
Vercel → Cloudflare Workers + Pages — Vercel had 80ms cold starts for the widget script. That's too slow for a file that loads on every pageview. Workers boot in 0ms.
Supabase → Cloudflare D1 + Drizzle — Supabase added a cross-region round-trip. D1 is co-located with Workers — queries are <1ms.
Regret: Priced by monthly updates — customers with sparse changelogs churned because they felt they weren't 'getting value.' Should have priced by reach (page impressions).
Advice: Price on the metric that grows with the customer's success. 'Updates per month' punishes responsible shippers. Reach or impressions aligns incentives better.
Nour A.— AI customer support deflection tool
$17k MRR13mo in prod
KEPT
Anthropic API — Claude's tool_use for structured ticket categorization. Accuracy is high enough that support managers stopped manually reviewing every classification.
Inngest — Async ticket processing pipeline. If Claude is slow, jobs queue and retry — customers never see a timeout error.
Neon — Per-customer schema isolation for conversation history. GDPR deletion is a single DROP SCHEMA statement.
REPLACED
OpenAI → Anthropic API — GPT-4o was hallucinating product names from our customers' knowledge bases. Claude's citations were more faithful to the source docs.
Intercom → Custom integration layer — Intercom's API rate limits capped us at 500 tickets/hour. At $17k MRR our customers process 10k/hour during peak.
Regret: Let enterprise customers upload training data without a file size cap. One customer uploaded a 4GB PDF that jammed the ingestion worker for 6 hours and took down processing for everyone else.
Advice: Cap every customer input: file size, token count, requests per minute. One outlier will always stress-test your limits in the worst possible moment.
Theo R.— SaaS database schema visualizer
$3.2k MRR9mo in prod
KEPT
Tinybird — Event tracking for schema diagram interactions. Tells me exactly which features users spend time on vs. ignore.
Hono — REST API on Cloudflare Workers. Database connection introspection in under 30ms globally.
Zod — Validate every SQL schema JSON payload at the edge before it touches any storage.
REPLACED
Mixpanel → Tinybird + custom dashboards — Mixpanel at $200/mo was expensive for a solo product. Tinybird at $25/mo with SQL I control is more informative anyway.
Express on Render → Hono on Workers — Render sleep mode was killing free trial users' first impression. Workers have no sleep and 0ms cold start.
Regret: Stored connection strings with credentials in plaintext for 4 months because implementing encryption was 'on the roadmap.' A customer noticed a security disclosure and tweeted about it.
Advice: Encrypt at-rest secrets before your first paying customer. Not before Series A — before the first credit card. You cannot unship a breach.
Leila M.— Fitness coaching platform
$7.4k MRR11mo in prod
KEPT
Mux — Workout video library with adaptive streaming. Coaches upload, Mux transcodes and delivers. I never touch ffmpeg.
Clerk — Coach + client org model. Role-based permissions so clients see only their assigned programs.
PostHog — Retention cohorts showed week-3 dropoff in every coaching program. Redesigned the check-in flow, 30-day retention doubled.
REPLACED
Vimeo Pro → Mux — Vimeo's API didn't support programmatic upload from coaches' mobile apps. Mux's direct upload URL works from any client.
Calendly → Cal.com (self-hosted) — Calendly was $12/user/month and we have 40 coaches. Cal.com self-hosted on Railway = $15/mo total.
Regret: Built a custom workout logging UI before validating coaches wanted to use an app vs. spreadsheets. Most coaches kept their spreadsheets anyway for the first 6 months.
Advice: Interview 10 coaches before writing one line of the workout logger. The feature you're most excited to build is rarely the one that drives retention.
Erik J.— SaaS background job monitoring
$4.4k MRR8mo in prod
KEPT
Axiom — Ingesting job execution logs from 200 customer queues at 20M events/day. $30/mo and queries return in under a second.
Upstash Redis — Job state cache with TTL. Serverless billing means $0 when customers' queues are quiet.
Resend — Alert emails for failed jobs with full stack traces inline. React Email makes them readable, not walls of text.
REPLACED
Datadog Logs → Axiom — Datadog was $400/mo at our log volume. Axiom at $30/mo does everything we need — APL queries, dashboards, alerts.
Amazon SQS → Trigger.dev — SQS + Lambda for our own internal jobs was $60/mo and 200 lines of infra config. Trigger.dev replaced it with 20 lines of TypeScript.
Regret: Sent job failure alerts via email only for the first 4 months. Every enterprise trial asked for Slack on day one. Lost 3 deals while I scrambled to ship the integration.
Advice: Ship Slack webhooks before email. In 2025, engineers live in Slack — email alerts get lost, Slack alerts get acted on immediately.
Preethi S.— SaaS API mock server for testing
$2.8k MRR7mo in prod
KEPT
Bun — Mock server startup time went from 800ms to 40ms. That's the difference between developers using it in watch mode or not.
Hono — The mock server itself is Hono. Customers define routes in TypeScript and it just works — familiar API, zero friction.
tsup — Ships ESM + CJS in one command. My npm package works in every environment without manual configuration.
REPLACED
Fastify → Hono — Fastify's TypeScript support required decorators and plugin types. Hono is first-class TypeScript with no magic.
ts-jest → Bun test — ts-jest added 30 seconds to CI per test run. Bun test runs the same suite in 2 seconds with native TypeScript support.
Regret: Didn't document the plugin API until month 5. Power users reverse-engineered it and built incompatible extensions. Formalizing it afterward required breaking changes.
Advice: Document your extension points before publishing. Even a one-page spec prevents the ecosystem from forking in incompatible directions.
Damien F.— SaaS upskilling platform for devs
$13k MRR16mo in prod
KEPT
Sanity — Lesson content modeled as Portable Text. Non-technical curriculum editors make changes without touching code.
Vercel — ISR rebuilds course pages when Sanity content changes. Zero stale content, zero manual cache purge.
Polar — Course bundles as one-time purchases and subscriptions. Polar's developer-focused checkout converted better than generic payment links.
REPLACED
Stripe Checkout → Polar — Stripe Checkout looked generic. Polar's checkout is built for digital products and shows GitHub-connected social proof at the point of sale.
Notion → Sanity — Notion as a CMS worked for the first 20 lessons. At 500 lessons the Notion API rate limits and messy block structure became unworkable.
Regret: Launched with video-only content. A significant portion of my audience is deaf or works in open offices. Adding captions to 200 videos retroactively was 2 weeks of work.
Advice: Add captions and transcripts to every video before launch. It doubles SEO value, improves accessibility, and serving three audiences (deaf, silent mode, skimmers) costs zero extra at recording time.
Valentina C.— AI-assisted code migration tool
$21k MRR14mo in prod
KEPT
Anthropic API — Claude handles large file contexts better than any other model. Migrating 1000-line files without losing logic requires a big context window used wisely.
GitHub API — PRs created programmatically per migration. Customers review changes in their existing GitHub workflow — no new UI to learn.
Railway — Long-running migration jobs need persistent compute. Railway's $10 plan with no timeout limit was the only managed platform that fit.
REPLACED
Vercel Functions → Railway — Vercel's 10s execution limit killed 80% of migration jobs mid-run. Railway has no timeout — migrations complete regardless of codebase size.
GPT-4o → Claude 3.5 Sonnet — GPT-4o drift on long files was a real problem — it would subtly change logic that wasn't part of the migration. Claude was more conservative.
Regret: Trusted AI output without a diff validation step for the first 3 months. Two customers shipped Claude-generated changes that introduced bugs because they trusted the PR without a careful review.
Advice: AI-generated code changes need a deterministic validation layer. Run the test suite, run the linter, gate the PR merge — make safety automatic, not optional.
Mike T.— Solo devtool: CLI scaffolding tool
$890 MRR3mo in prod
KEPT
Bun — CLI starts in 12ms. Users run this on every new project — startup speed is the product.
Biome — Zero-config linting on generated code. Users get clean output without installing separate lint tooling.
tsup — Publishes to npm in one command. CJS + ESM + types from a single config.
REPLACED
Inquirer.js → clack (by @natemoo-re) — Inquirer prompts are functional but ugly. clack's spinners and styled prompts made the CLI feel premium with zero extra code.
commander.js → citty — Commander's TypeScript types were loose and manual. citty infers argument types from the definition — no separate type declaration needed.
Regret: Released to npm without a lock on Node version. Windows users on Node 18 got a broken install. Added engines field after 20 GitHub issues.
Advice: Set engines.node in package.json before publishing. Test on Windows in CI. The longtail of developer environments will find bugs your Mac never will.
Grace H.— B2B SaaS data pipeline builder
$31k MRR22mo in prod
KEPT
Trigger.dev — Customer-defined pipelines as durable workflows. Each step retries independently — partial failures don't restart the whole pipeline.
Neon — Pipeline run history isolated per customer in separate Postgres branches. GDPR deletion is surgical.
Clerk — API keys with scoped permissions for each integration. Clerk's machine-to-machine tokens saved a month of auth work.
REPLACED
Temporal → Trigger.dev — Temporal required a cluster to run, Helm charts, and a dedicated ops person. Trigger.dev is the same model with zero infra.
Heroku → Railway — Heroku's eco dynos were sleeping mid-pipeline for inactive customers. Railway keeps the service up for $5/mo — no sleeps.
Regret: Allowed customers to define pipeline steps with arbitrary Node.js eval for the first 6 months. Removed it after a customer accidentally exhausted memory on the shared host.
Advice: Never expose eval or exec to customers, even early adopters. Sandbox every user-defined code path from day one — retrofitting sandboxing is orders of magnitude harder than building it in.
Serena T.— Content repurposing SaaS
$5.9k MRR9mo in prod
KEPT
Vercel AI SDK — useChat hook handles streaming, error states, and message history. Saved a week of state management work.
Cloudflare R2 — Storing original and repurposed content assets. Free egress means I never pay for the most common operation — reading content back.
Loops — Behavioral trigger emails when repurposed content is ready. Loops' event-driven model is built for exactly this — not a newsletter tool bolted onto SaaS.
REPLACED
Customer.io → Loops — Customer.io's pricing jumped to $200/mo at 5k contacts. Loops is $49/mo and purpose-built for SaaS transactional emails.
Uploadthing → Cloudflare R2 + presigned URLs — Uploadthing was a great DX but the egress costs at scale were a surprise. R2 presigned URLs are 20 lines of code and free egress.
Regret: Used the OpenAI streaming API directly without an abstraction layer. When I switched to Claude for better quality, I had to rewrite every streaming component.
Advice: Abstract your AI provider behind a single interface from the start. Model switching is inevitable — make it a one-line config change, not a week of refactoring.
Lars N.— Open-core developer security scanner
$6.3k MRR12mo in prod
KEPT
GitHub Actions — Our scanner runs in CI as a GitHub Action. Distribution as an action means zero install friction — customers just add one line to their workflow.
Polar — Open-core monetization with GitHub-connected license validation. Solo devs sponsor for free, teams pay for the SaaS dashboard.
Railway — The dashboard backend on Railway. $10/mo, deploys from git push, scales with traffic.
REPLACED
Stripe → Polar — Stripe for open-source is weird — monthly invoices for a tool people think of as free felt wrong. Polar's GitHub-integrated model matched what users expected.
Self-hosted Posthog → Plausible — PostHog self-hosted needed 4GB RAM and regular maintenance. For a side project, Plausible at $9/mo is all I actually need.
Regret: Didn't add a license check to the paid features until month 5. Power users were using pro features for free because I never enforced the gate.
Advice: Ship the license enforcement at the same time as the paid features, not later. Retroactively cutting off users who've built workflows around your tool is way more painful than starting with a hard gate.
Jason W.— SaaS workflow automation
$0 (shut down) MRR18mo in prod
KEPT
Stripe — The only tool that worked flawlessly throughout the entire disaster. Refunds processed cleanly when we shut down.
REPLACED
Heroku → Nothing (company died) — Heroku removed free dynos in Nov 2022. Our costs went from $0 to $250/mo overnight. For a pre-revenue project, that was fatal.
Heroku Postgres → Nothing (company died) — The Postgres add-on jumped from free to $50/mo minimum. Combined with dyno costs, we couldn't justify continuing.
Regret: Built the entire product on Heroku free tier assuming it would exist forever. When they killed it, we had 2 months to migrate or die. We died.
Advice: Never build a business on a free tier you don't control. If the provider can kill your economics with one blog post, you don't have a business — you have a hobby on borrowed time.
Rachel D.— E-learning marketplace
$0 (shut down) MRR24mo in prod
KEPT
Cloudflare — CDN and DNS were the only things that never failed us. Moved everything behind CF after the Firebase disaster.
REPLACED
Firebase → Attempted Supabase migration (failed) — Firestore bill hit $14,000 in one month. A student bot was making 2M reads/hour on our public course catalog. No way to retroactively add rate limiting to Firestore.
Firebase Auth → Attempted migration (too late) — Couldn't export password hashes from Firebase Auth. 40k users would need to reset passwords. Migration was impossible without destroying UX.
Regret: Firebase lock-in killed us. $14k surprise bill, couldn't migrate auth, couldn't add rate limits to Firestore. We were trapped in a burning building with no exits.
Advice: If you can't export your users' auth data, you don't own your product. Check the data portability story BEFORE you commit to any auth provider.
Daniel P.— Real-time logistics dashboard
$34k MRR26mo in prod
KEPT
PostgreSQL (self-hosted) — After the MongoDB Atlas disaster, we moved everything to self-hosted Postgres on Hetzner. Full control, predictable costs.
REPLACED
MongoDB Atlas → PostgreSQL (self-hosted) — Atlas auto-scaled our cluster from M30 to M60 during a traffic spike without asking. $4,200 bill for one weekend. Support said 'that's how auto-scaling works.'
Datadog → Grafana + Prometheus (self-hosted) — Datadog custom metrics bill went from $200/mo to $2,800/mo when we added vehicle telemetry. Each GPS ping was a custom metric. No warning until invoice.
Regret: Trusted 'auto-scaling' without setting hard spending caps. MongoDB Atlas and Datadog both scaled our bill, not our service. We lost $18k in surprise charges over 3 months before we caught it.
Advice: Set billing alerts at 50%, 80%, and 100% of your expected spend on EVERY service. Auto-scaling without spending caps is an open credit card with no limit pointed at a SaaS vendor.
Sophie L.— SaaS content calendar tool
$8.2k MRR19mo in prod
KEPT
Stripe — Payments kept working through the entire 6-month migration. Only stable thing in the stack.
Resend — Transactional emails were the one thing we didn't have to migrate.
REPLACED
PlanetScale → Neon (6-month migration) — PlanetScale killed their free tier and then their Hobby plan. Migrating 800 tables with foreign key workarounds back to real Postgres took 6 months of part-time work.
Vercel → Cloudflare Pages — Vercel bandwidth bill hit $340/mo for what turned out to be image assets served without caching headers. Their dashboard didn't show this until I opened a support ticket.
Regret: PlanetScale's no-foreign-keys philosophy infected our schema design. When we moved to Postgres, we had to reverse-engineer referential integrity for 800 tables. Six months of my life, gone.
Advice: If a database requires you to abandon fundamental SQL features, you're not using an innovation — you're accumulating debt. Foreign keys exist for a reason.
Maxim K.— Developer API platform
$45k MRR20mo in prod
KEPT
Cloudflare Workers — Edge functions stayed up when everything else died. Our status page ran on Workers — ironically the only thing customers could see during the outage.
REPLACED
Vercel → Self-hosted on Hetzner — Vercel had a 4-hour outage that took our entire API down. Our customers' apps broke because our API was down. We lost 3 enterprise contracts worth $12k/mo ARR.
Vercel Edge Config → Cloudflare KV — During the Vercel outage, Edge Config was unreachable too. Feature flags that controlled customer API behavior all defaulted to 'off'. Revenue-generating features disappeared for 4 hours.
Regret: Put all eggs in one provider basket. When Vercel went down, our API, our dashboard, our feature flags, and our docs all died simultaneously. One outage cost us $144k in lost annual contracts.
Advice: Distribute critical infrastructure across at least two providers. Your status page, your API, and your dashboard should never share a single point of failure.
Ingrid B.— HR tech — employee engagement platform
$11k (was $22k) MRR30mo in prod
KEPT
PostgreSQL (AWS RDS) — The database itself was never the problem. Rock-solid for 30 months.
REPLACED
Auth0 → Clerk (in progress) — Auth0 raised prices 3x after Okta acquisition. Went from $228/mo to $740/mo for the same feature set. Migration has taken 4 months so far because of custom rules and SAML configs.
Twilio → Still searching — Twilio SMS costs doubled when they changed their pricing model. Our 2FA costs went from $400/mo to $900/mo. No clear alternative for global SMS delivery.
Regret: Built our entire auth flow on Auth0 custom rules and actions. When they tripled pricing, we couldn't leave because 18 months of business logic was embedded in their proprietary scripting layer.
Advice: Never put business logic in a vendor's proprietary extension system. Auth rules, serverless functions, custom workflows — if you can't copy-paste it to another provider, it's lock-in disguised as convenience.
Carlos M.— Fintech payment aggregator
$67k MRR28mo in prod
KEPT
Stripe — Connect continued processing while everything else burned. Stripe's infrastructure is genuinely reliable.
REPLACED
AWS Lambda → ECS Fargate — Lambda cold starts caused payment webhook processing to time out. Three customers' payments were marked as failed when they actually succeeded. Reconciliation took 2 weeks.
AWS API Gateway → ALB + ECS — API Gateway had a regional outage for 47 minutes. In fintech, 47 minutes of downtime means regulatory reporting, customer compensation, and a board meeting.
Regret: Chose serverless for a payment processing system because it was trendy. Payments need predictable latency and always-on compute. Lambda's cold start variance is unacceptable when money is moving.
Advice: Serverless is wrong for payment processing. You need warm, always-on, predictable-latency compute. The cost savings of Lambda are meaningless when one cold start causes a double-charge.
Emma V.— SaaS booking platform for salons
$5.1k (was $9k) MRR16mo in prod
KEPT
Supabase — Database and auth remained solid. The only part of our stack that didn't betray us.
REPLACED
Algolia → Meilisearch (self-hosted) — Algolia sent us a 'pricing update' email. Our search bill went from $70/mo to $290/mo — same usage, new pricing tier. They gave 30 days notice.
Twilio → Resend + custom SMS via Vonage — Twilio SMS deliverability in Europe degraded over 3 months. Appointment reminders were arriving 20-40 minutes late. Support blamed carrier networks. Salons lost clients.
Regret: Relied on Twilio SMS for critical appointment reminders without a fallback channel. When delivery degraded, salons lost no-show revenue and blamed us. We lost 40% of customers in 2 months.
Advice: Critical notifications need at least two delivery channels. SMS + email + push. If one channel degrades silently, the others catch it. Never depend on a single notification path for revenue-critical alerts.
Felix G.— Developer documentation platform
$14k MRR22mo in prod
KEPT
Cloudflare — Pages and Workers were our escape hatch. Migrated off Netlify in 3 days because Cloudflare's compatibility was excellent.
REPLACED
Netlify → Cloudflare Pages — Netlify deprecated their build image mid-contract. Our custom build plugin broke. Support response took 5 business days. For a documentation platform, 5 days of broken deploys is catastrophic.
Netlify Functions → Cloudflare Workers — Functions had unexplained 3-second cold starts that appeared after a platform update. No changelog entry, no notice. Our API felt broken to users for 2 weeks before we traced it to Netlify.
Regret: Netlify was great in 2021, degraded silently in 2023-2024. Performance worsened, features broke without notice, support got slower. We ignored the signs for 8 months because migration felt hard.
Advice: Monitor your hosting provider's performance over time, not just at evaluation. Set up synthetic checks. If p95 latency creeps up 20% over a quarter with no code changes, it's time to evaluate alternatives.
Anna K.— GDPR compliance automation tool
$19k MRR15mo in prod
KEPT
Hetzner (EU) — After the Supabase data residency scare, we moved everything to Hetzner in Frankfurt. Full control over data location.
REPLACED
Supabase → Self-hosted Postgres on Hetzner — Discovered Supabase was routing some queries through US-based pooling infrastructure. For a GDPR tool, having customer PII transit through US servers was a potential compliance violation.
Vercel → Cloudflare Pages (EU-only) — Vercel's edge network processes requests globally before routing to the origin. German enterprise customers demanded proof that no request touched a US server. Vercel couldn't provide it.
Regret: Built a GDPR compliance tool on infrastructure that itself had GDPR gray areas. When an enterprise customer's DPO audited our stack, they found potential data transfer issues we hadn't considered.
Advice: If you're in the compliance space, your own infrastructure must be squeaky clean. Run everything in EU-only regions. No edge networks that might touch US servers. Your customers' auditors will check YOUR infra, not just your code.
Patrick O.— SaaS fleet management
$0 (shut down) MRR14mo in prod
KEPT
Nothing — The whole stack was the problem. We over-engineered everything on AWS and burned through our runway maintaining infrastructure instead of building product.
REPLACED
AWS (full stack) → Nothing (company died) — Lambda + DynamoDB + API Gateway + SQS + SNS + S3 + CloudFront + Cognito. $3,200/mo in AWS bills for 50 users. We hired a DevOps engineer just to maintain it. Ran out of money.
AWS Cognito → Nothing (company died) — Cognito's custom auth flows required 4 Lambda triggers. Each had cold starts. Login took 3-4 seconds. Users thought the app was broken.
Regret: AWS was the wrong choice for a seed-stage startup. We spent 60% of engineering time on infrastructure. Our competitors shipped features while we wrote CloudFormation templates.
Advice: AWS is for companies with DevOps teams. If you're a 2-person startup, use managed platforms (Railway, Vercel, Supabase). The $200/mo you save on AWS isn't worth the 40 hours/month you spend maintaining it.
Mila R.— SaaS invoice generator
$3.1k (was $5.8k) MRR13mo in prod
KEPT
Stripe — Billing continued to work perfectly. Ironic that our payment tool was the most reliable part of a billing product.
REPLACED
Firebase → Supabase (painful migration) — Google deprecated the Firebase Extensions we depended on for PDF generation. 2 months notice. Our entire invoice rendering pipeline broke on deprecation day.
Firebase Hosting → Vercel — Firebase Hosting rewrites stopped working after a platform update. Our SPA routing broke for 6 hours. Google's support response: 'This is expected behavior with the new hosting version.'
Regret: Google kills products. We knew this and used Firebase anyway because the DX was good. When they deprecated the Extensions API we depended on, we had 60 days to rewrite core functionality or break.
Advice: Check Google's product graveyard before building on any Google service. If it's not generating ad revenue, it's at risk. Firebase Extensions, Cloud Functions v1, Firestore export — all deprecated with minimal notice.
Viktor S.— Real-time collaboration whiteboard
$7.8k (was $12k) MRR20mo in prod
KEPT
Hetzner — Moved WebSocket servers to Hetzner after the Vercel serverless debacle. Predictable pricing, actual servers.
REPLACED
Vercel Serverless → Hetzner VPS + Docker — Vercel serverless functions can't maintain WebSocket connections. We hacked around it with polling, which added 200ms latency to every collaboration action. Users complained for months before we understood why.
Supabase Realtime → Custom WebSocket server — Supabase Realtime hit connection limits at 200 concurrent users per project. Support said to upgrade to Pro, but Pro only raised it to 500. We needed 5000.
Regret: Chose serverless hosting for a real-time collaborative app. Serverless and WebSockets are fundamentally incompatible. We spent 8 months fighting the architecture before accepting we needed actual servers.
Advice: Real-time features need stateful servers. Period. Serverless is for request-response. If your product's core value is real-time collaboration, start with WebSocket-capable infrastructure from day one.
Natasha Y.— Customer feedback analytics
$9.5k MRR17mo in prod
KEPT
Neon — Moved from PlanetScale after the shutdown announcement. Neon's Postgres compatibility meant our Prisma schema worked as-is.
REPLACED
PlanetScale → Neon — PlanetScale announced Hobby plan shutdown. We had 3 months to migrate 200GB of customer feedback data. The migration tool they provided failed on tables over 10GB. Had to write custom ETL scripts.
Heroku → Railway — Heroku's performance degraded after the Salesforce acquisition. Response times crept from 120ms to 400ms over a year. Support said it was 'expected variance.' Left after 6 months of complaints.
Regret: Used PlanetScale because it was the hot new thing in 2023. When they killed the free tier and then the Hobby tier, we were trapped with a MySQL-compatible DB in a Postgres-dominated ecosystem. Migration was hell.
Advice: Choose boring technology for your database. PostgreSQL has survived 30 years. VC-funded database startups have not. If your DB provider needs to 'find a business model,' your data is at risk.
James C.— SaaS appointment scheduling
$6.2k (was $11k) MRR21mo in prod
KEPT
Cal.com (self-hosted) — After the Calendly API disaster, we self-hosted Cal.com. Full control, no API changes without our consent.
REPLACED
Calendly API → Cal.com (self-hosted) — Calendly changed their API from v1 to v2 with 90 days notice and no backward compatibility. Our integration broke on cutoff day. 800 customers couldn't book appointments for 12 hours.
Auth0 → Better Auth — Auth0 deprecated their 'Lock' widget we used in 50 customer-facing booking pages. Replacement ('Universal Login') required redesigning every page. 3 months of work for zero new features.
Regret: Built core product functionality on third-party APIs that changed without mercy. Calendly's v1→v2 migration and Auth0's Lock deprecation hit in the same quarter. We lost 40% of customers during the chaos.
Advice: If your product depends on a third-party API, monitor their changelog religiously. When they announce a deprecation, start migrating that day — not when the deadline arrives. 90 days disappears fast.
Olivia T.— E-commerce personalization engine
$23k MRR18mo in prod
KEPT
Cloudflare Workers — Edge personalization stayed up. The only reliable part of our stack during the Algolia crisis.
REPLACED
Algolia → Typesense (self-hosted) — Algolia had a 6-hour indexing delay during Black Friday. Our customers' product search was serving stale results. Support response: 'We're experiencing elevated indexing latency.' No ETA. Lost an estimated $200k in GMV for our customers.
Datadog → Axiom — Datadog's custom metrics pricing changed without notice. Our bill jumped from $800/mo to $3,400/mo because they reclassified our tag cardinality. Took 2 months to negotiate back down.
Regret: Trusted Algolia with Black Friday traffic without a fallback. When their indexing broke, we had no degradation strategy. Customers saw products marked 'out of stock' that were actually available. Revenue evaporated.
Advice: Any third-party service in your revenue path needs a fallback. Cache last-known-good results. If search breaks, serve stale results — that's infinitely better than broken results or errors.
Raj P.— SaaS customer onboarding tool
$15k (dropping) MRR16mo in prod
KEPT
Vercel — Frontend hosting itself was fine. It's the backend services that betrayed us.
REPLACED
Supabase → Self-hosted Postgres + custom auth — Supabase had an outage that took down our dashboard for 3 hours during a product demo to a $50k/yr prospect. They went with a competitor. Supabase's status page showed 'degraded performance' — not 'total outage.'
Intercom → Custom solution — Intercom raised prices from $74/mo to $240/mo at renewal. Same features, same seat count. When we asked why: 'Our pricing has been updated to reflect the value we provide.' Left within 60 days.
Regret: Lost our biggest potential deal because Supabase went down during the one hour that mattered most. We had no self-hosted fallback, no read replica, nothing. One outage, one lost deal, one lesson.
Advice: For critical demos and enterprise sales, have a self-hosted fallback you can switch to in 5 minutes. Or at minimum, pre-record a backup demo. Never depend on SaaS uptime for a six-figure deal.
Monica L.— AI writing assistant for legal teams
$28k MRR22mo in prod
KEPT
Anthropic API — Claude has been the most stable API in our stack. Never broke compatibility, never surprised us with pricing.
REPLACED
OpenAI → Anthropic API — OpenAI deprecated text-davinci-003 with 3 months notice. Our fine-tuned legal model couldn't be ported to turbo. 6 months of training data and $40k in fine-tuning costs — gone.
MongoDB Atlas → Neon — Atlas's 'Flex' tier migration forced us to rewrite queries that used features removed in the tier change. They framed it as an 'upgrade.' It was a downgrade with a forced migration deadline.
Regret: Invested $40k in fine-tuning OpenAI models that were deprecated 8 months later. The models were deleted from their servers. No export, no migration path, no refund. Forty thousand dollars, gone.
Advice: Never invest heavily in fine-tuning a model you can't export. If the provider can delete your model with one deprecation notice, you're renting capability — not building an asset.
Tobias H.— SaaS CI/CD pipeline builder
$0 (shut down) MRR11mo in prod
KEPT
Nothing survived — AWS vendor lock-in killed us. Couldn't afford to run, couldn't afford to migrate.
REPLACED
AWS CodePipeline + CodeBuild → Nothing (company died) — AWS changed CodeBuild pricing from per-minute to per-build with a minimum charge. Our CI costs went from $400/mo to $2,100/mo overnight for the same workload.
AWS ECS → Nothing (company died) — ECS task costs with NAT Gateway egress fees added $800/mo we hadn't budgeted. Every Docker pull, every API call — all charged through NAT. The bill was incomprehensible.
Regret: AWS bills are designed to be impossible to predict. NAT Gateway, data transfer, API calls — hidden costs everywhere. We were profitable on paper but bleeding $2k/mo we couldn't trace until month 8.
Advice: If you use AWS, hire someone who's read every pricing page. NAT Gateway alone can 10x your bill. Or just use Railway/Render/Fly and know exactly what you'll pay. AWS pricing complexity is a feature, not a bug — for Amazon.
Katarina S.— SaaS social proof widget
$4.8k (was $8.5k) MRR14mo in prod
KEPT
Cloudflare Workers — Widget serving stayed up throughout. Edge delivery is the one thing that never let us down.
REPLACED
Firebase Realtime DB → Upstash Redis — Firebase Realtime DB had a pricing change that charged per-connection instead of per-operation. Our widget opened a connection on every page load across all customers' sites. Bill went from $80/mo to $1,900/mo.
Vercel → Cloudflare Pages — Vercel's usage-based billing charged for every widget script request. One customer's viral TikTok drove 2M requests in a day. We got a $600 overage bill for serving a 2KB JavaScript file.
Regret: Usage-based pricing on tools that serve third-party widget traffic is a trap. Our customers' traffic spikes become our billing emergencies. One viral moment nearly bankrupted us.
Advice: If your product embeds on other people's sites, you need fixed-cost hosting with unlimited bandwidth. Usage-based pricing + third-party embeds = unpredictable bills that correlate with your customers' success, not yours.
Leo F.— SaaS email marketing platform
$18k (dropping) MRR19mo in prod
KEPT
PostgreSQL (self-hosted) — Our database has been the only stable thing. Self-hosted on Hetzner, predictable, boring, reliable.
REPLACED
AWS SES → Postmark — AWS SES changed their bounce handling policy without notice. Our sender reputation score dropped from 95 to 62 in one week. Deliverability tanked. 30% of emails going to spam. Took 3 months to recover.
Datadog → Grafana Cloud — Datadog's APM pricing was per-host per-month. We auto-scaled during email sends. 4 hosts became 12 hosts for 2 hours, but Datadog charged for 12 hosts for the full month. $2,400 for 2 hours of scaling.
Regret: AWS SES's silent policy change destroyed our deliverability. We lost 15% of customers because their campaigns started failing. No notice, no migration period, no way to appeal. Amazon doesn't care about your startup.
Advice: For email infrastructure, pay more for a provider that communicates. SES is cheap until it ruins your sender reputation with a policy change. Postmark, Resend, Mailgun — they're more expensive but they'll warn you before they break your business.
Aisha N.— Healthcare appointment platform
$42k MRR24mo in prod
KEPT
Hetzner (EU only) — After discovering our patient data had been processed in US regions, we moved everything to EU-only Hetzner. Never again.
REPLACED
Vercel → Self-hosted on Hetzner — Vercel edge functions processed patient appointment data in their global network. Our HIPAA-equivalent audit revealed patient names were being cached in US CDN nodes. Compliance violation.
Auth0 → Keycloak (self-hosted) — Auth0's EU region had a 2-hour outage. Doctors couldn't access patient records. In healthcare, 'service temporarily unavailable' can mean missed diagnoses. We can't outsource availability to a SaaS.
Regret: Used SaaS tools without verifying their data processing locations. Auditors found patient PII transiting through 6 countries via CDN, edge functions, and auth redirects. Compliance remediation cost $120k.
Advice: In healthcare and regulated industries, map every byte's geographic path before you launch. CDNs, edge functions, auth redirects — data touches more servers than you think. Your compliance team needs a network diagram, not a vendor list.
Ryan M.— SaaS project management for agencies
$12k (was $19k) MRR25mo in prod
KEPT
Linear — We use Linear internally and it's been flawless. Wish we'd built on something equally stable for our product.
REPLACED
Heroku → Railway — Heroku's performance degraded steadily after 2022. P95 response times went from 80ms to 350ms over 18 months with no code changes. Their performance dynos cost 4x for the same throughput we got in 2021.
Pusher → Soketi (self-hosted) — Pusher raised connection limits from 100 to 200 concurrent per 'channel' but reduced the total connections per plan by 60%. Net effect: 40% less capacity at the same price. Migration took 3 months.
Regret: Stayed on Heroku for 18 months too long because 'migration is risky.' The slow performance degradation cost us more customers than a weekend migration would have. Boiling frog syndrome.
Advice: Set performance SLOs for your hosting provider, not just your code. If p95 latency increases 50% over a quarter with no code changes, start evaluating alternatives immediately. Don't wait for the breaking point.
Chen W.— Developer API analytics
$16k MRR18mo in prod
KEPT
ClickHouse (self-hosted) — After the Tinybird pricing scare, we self-hosted ClickHouse. More work, but no one can change our pricing overnight.
REPLACED
Tinybird → ClickHouse (self-hosted) — Tinybird changed their pricing from events-based to queries-based. Our customers run heavy analytics dashboards. Bill projection went from $200/mo to $1,800/mo. No grandfather clause for existing customers.
Vercel → Fly.io — Vercel's function invocation pricing hit us hard. Our API analytics endpoint processes 50M requests/month. At $0.60 per million invocations, that's $30/mo for invocations alone — on top of compute time.
Regret: Tinybird's pricing model change turned our profitable unit economics into a loss overnight. We had 2 months to either eat the cost increase or rewrite our analytics stack. Chose rewrite. Lost 3 months of product development.
Advice: When a vendor's pricing model changes, they'll frame it as 'simpler' or 'more predictable.' Run your actual usage through the new model IMMEDIATELY. 'Simpler' usually means 'more expensive for heavy users.'
Helen A.— SaaS document signing platform
$31k MRR26mo in prod
KEPT
AWS S3 (Frankfurt only) — Document storage on S3 with strict region policies. After the Cloudflare incident, S3 with lifecycle policies is our source of truth.
REPLACED
Cloudflare R2 → AWS S3 (region-locked) — Cloudflare R2 had a data durability incident that affected our bucket. 3 signed documents were unrecoverable. For a document signing platform, losing even one signed contract is existential. Cloudflare's SLA offered $50 credit.
Netlify → Vercel — Netlify's build system had a vulnerability that was disclosed publicly before they patched it. Our legal documents' build previews were technically accessible for 48 hours. Compliance team lost their minds.
Regret: Chose Cloudflare R2 for cost savings ($0 egress) over AWS S3's 99.999999999% durability guarantee. Saved $200/mo, lost 3 legal documents that can never be recreated. The cheapest option cost us the most.
Advice: For documents that can never be recreated (legal, financial, medical), pay for maximum durability. S3 Standard with cross-region replication. R2 and alternatives are fine for images and logs. Not for irreplaceable documents.
Stefan K.— SaaS subscription box management
$8.9k (was $14k) MRR20mo in prod
KEPT
Stripe — Billing worked perfectly. The one service we'd never replace.
REPLACED
Shippo → EasyPost — Shippo's API had a silent regression that miscalculated shipping rates for 2 weeks. Our customers were charged $3-5 less than actual shipping cost. We ate $12,000 in rate differences before noticing.
MongoDB Atlas → Supabase — Atlas auto-upgraded our cluster to a 'recommended' version that broke our aggregation pipelines. No rollback possible. 6 hours of downtime debugging query compatibility issues on a Sunday.
Regret: Trusted third-party APIs without validation layers. Shippo returned incorrect rates silently — no error, no warning. We invoiced customers at the wrong price for 2 weeks. Silent failures are worse than loud crashes.
Advice: Validate every response from every third-party API against expected ranges. If a shipping rate comes back 50% lower than historical average, flag it for review. Trust but verify — especially for anything involving money.
Nina P.— AI writing assistant
$22k MRR11mo in prod
KEPT
OpenRouter — One API for every model. Switch between Claude, GPT-4o, Llama without code changes. Essential for an AI product.
Langfuse — LLM observability that actually works. Track cost per user, per feature, per model. Found that 8% of users consumed 60% of our token budget.
Vercel — Edge functions for streaming responses. Deploy previews for prompt testing. Just works.
REPLACED
OpenAI direct → OpenRouter — Needed model flexibility. When Claude 4 dropped, we switched in 5 minutes. With OpenAI direct, it would have been a migration project.
Custom logging → Langfuse — Our custom trace logging was 2000 lines of code that showed us nothing useful. Langfuse replaced it with 20 lines and 100x better insights.
Clerk → Better Auth — At 15k MAU, Clerk was $325/mo just for auth. Better Auth is free, open source, and took a weekend to migrate.
Regret: Didn't add cost tracking from day one. By month 4, our LLM bill was $3,800/mo and we had no idea which features were profitable. Langfuse showed us our 'smart suggestions' feature cost $0.12/use but generated zero engagement.
Advice: If you're building an AI product, instrument LLM costs per-feature from day one. Not month six when your bill is already out of control. Langfuse or similar — just do it.
David R.— Local-first project management
$3.1k MRR8mo in prod
KEPT
ElectricSQL — Our entire value prop is offline-first. Electric syncs Postgres to the browser. Users work offline on planes, sync when they land. Magic.
PGlite — Full Postgres in the browser via WASM. Users get a real database locally — queries, joins, indexes. Paired with Electric for sync.
Fly.io — Multi-region Postgres close to users. Electric sync is fast when the server is nearby. $30/mo for global coverage.
REPLACED
Supabase Realtime → ElectricSQL — Supabase Realtime needs a connection. Our users are often offline (construction teams, field workers). Electric's sync model works with intermittent connectivity.
IndexedDB (raw) → PGlite — Raw IndexedDB is a nightmare. No SQL, no indexes worth using, no query planner. PGlite gives us real Postgres locally. Night and day.
Regret: Underestimated the complexity of conflict resolution. When two users edit the same task offline and sync later, you need a strategy. We spent 3 weeks building merge logic that Electric's CRDT support mostly handles.
Advice: Local-first is the future but the tooling is still early. Budget 2x your estimated time for sync edge cases. Users will do things you never imagined — edit the same field on two devices 6 hours apart and expect both changes to survive.
Yuki T.— Developer tool marketplace
$9.5k MRR14mo in prod
KEPT
Convex — Replaced our entire backend — database, realtime, scheduling, file storage. One service instead of five. Fewer bills, fewer failure points.
Biome — Replaced ESLint + Prettier. Our CI lint step went from 45 seconds to 0.8 seconds. Dev experience improved overnight.
Polar — Developer monetization done right. Subscriptions, one-time purchases, and sponsorship in one dashboard. Lower fees than Stripe for digital products.
REPLACED
Supabase → Convex — Supabase was great but we were using Supabase + Inngest + Uploadthing + pg_cron. Convex does all four. Fewer services = fewer integration bugs.
ESLint + Prettier → Biome — ESLint config hell. 47 plugins, conflicting rules, 12-second lint times. Biome: one config file, sub-second linting, zero conflicts.
Stripe → Polar — Stripe is overkill for digital products. Polar handles developer subscriptions natively. No tax filing — they're the Merchant of Record.
Regret: Spent two months building a custom admin dashboard before discovering Twenty (open source CRM). Could have self-hosted Twenty in a day and had a better UI than what we built.
Advice: Before building any internal tool, search for an open source alternative. Twenty for CRM, Docmost for docs, Coolify for PaaS. The open source ecosystem in 2026 is incredible — most internal tools already exist.
Marco B.— AI code review platform
$7.2k MRR9mo in prod
KEPT
Cerebras — 2000 tokens/sec on Llama 3.3 70B. Our code reviews feel instant. Users compare us to competitors and say 'yours feels like it's already done before I finish clicking'.
Encore — Backend with built-in tracing — every API call, every pub/sub message, visible in the trace viewer. When something breaks, we know exactly where in under a minute.
Neon — Serverless Postgres with branching. Every PR gets its own database branch. Test data isolation without managing multiple databases.
REPLACED
OpenAI GPT-4o → Cerebras (Llama 3.3 70B) — GPT-4o: 80 tok/s, $0.005/1K output. Cerebras Llama 70B: 2000 tok/s, $0.0006/1K output. 25x faster, 8x cheaper. Quality is 90% as good for code review tasks.
Express.js → Encore — Express was fine until we needed pub/sub, cron, and tracing. Adding those meant 4 more services. Encore has them built-in with zero config.
Regret: Overthought model selection. Tested 12 models over 6 weeks before launching. Should have shipped with GPT-4o, then optimized. Users don't care which model — they care about speed and accuracy.
Advice: For AI products: ship with any good model, then optimize. Cerebras + open models can replace GPT-4o for many tasks at 1/10th the cost. But you won't know which tasks until you have real user data.
Sophie L.— Developer education platform
$3.8k MRR7mo in prod
KEPT
Better Auth — Zero cost for auth. Self-hosted, no per-user fees. At 15k users we'd be paying $300+/mo on Clerk.
Hono — API routes are lightning fast on Cloudflare Workers. Cold starts don't exist. Middleware system is cleaner than Express.
Turso — Edge SQLite databases. Each user gets their own database. Per-tenant isolation without managing 1000 Postgres instances.
REPLACED
Clerk → Better Auth — Clerk was great but $95/mo at 12k MAU. Better Auth is free, self-hosted, and we own the user data completely.
Express.js → Hono — Express middleware ordering bugs were constant. Hono's type-safe middleware chain eliminated an entire class of bugs.
Regret: Started with Vercel but our API routes needed long-running connections. Should have used Cloudflare Workers from day one for WebSocket support.
Advice: If your auth bill will exceed $50/mo within 6 months, use Better Auth or Lucia from the start. Migration later is painful.
Ryan P.— Real-time collaboration tool
$22k MRR15mo in prod
KEPT
Convex — Real-time sync without writing a single WebSocket handler. Our entire backend is 400 lines of Convex functions. Would have been 4000 lines with Supabase + custom sync.
Clerk — Organization features saved us months. Team invites, role management, SAML SSO — all out of the box.
Vercel — v0 helped us prototype UI 10x faster. The AI + deploy pipeline is unmatched.
REPLACED
Firebase → Convex — Firestore's eventual consistency caused phantom writes in our collaborative editor. Convex's ACID transactions fixed it instantly.
Pusher → Convex (built-in) — Pusher was $49/mo for 500 connections. Convex includes real-time sync. One less service to manage.
Regret: Didn't invest in proper error boundaries early. When Convex had a 20-minute outage, our entire app crashed instead of showing cached state.
Advice: For collaborative apps: Convex or Electric SQL. Don't build real-time sync yourself — it's a years-long rabbit hole.
Ana V.— AI content studio
$15k MRR12mo in prod
KEPT
Groq — Llama 3.3 70B at 1200 tok/s. Our content generation feels instant. Users say it's faster than typing.
Langfuse — LLM observability is non-negotiable. We track every prompt, every token, every cost. Found a prompt regression that was costing us $200/day in wasted tokens.
Inngest — Content pipelines with 8 steps (generate → edit → SEO → images → format → review → publish → notify). Inngest handles retry, parallelism, and rate limiting.
REPLACED
OpenAI GPT-4o → Groq (Llama 3.3 70B) — GPT-4o was $0.005/1K output tokens. Groq is $0.0006/1K. For content generation, quality difference is negligible. 8x cost savings.
BullMQ → Inngest — BullMQ job failures at 3am with no visibility. Inngest's dashboard shows exactly which step failed, with replay capability.
Regret: Built our own prompt management system. Should have used Langfuse's prompt management from day one. Wasted a month rebuilding what they already had.
Advice: Add Langfuse on day one of any AI product. Prompt costs, latency, and quality regressions are invisible without observability.
Tom H.— Local-first note-taking app
$5.1k MRR10mo in prod
KEPT
ElectricSQL — Postgres sync to the client. Users' notes are available offline, sync when connected. No conflict resolution code — ElectricSQL handles it.
PGlite — Full Postgres in the browser. Users run complex queries on their local data. No round-trips to the server for filtering and search.
Fly.io — Multi-region Postgres for the sync server. Users in Tokyo sync with Tokyo, users in Frankfurt sync with Frankfurt.
REPLACED
SQLite (raw) → PGlite — PGlite gives us full Postgres features in the browser — JSONB, full-text search, CTEs. SQLite in WASM was limited.
Custom sync engine → ElectricSQL — Our custom sync had 47 edge cases. ElectricSQL handled all of them. Replaced 2000 lines of conflict resolution code.
Regret: Spent 3 months building custom CRDT sync before discovering ElectricSQL. Should have researched the local-first ecosystem first.
Advice: If you're building local-first: ElectricSQL + PGlite. Don't build your own sync. The edge cases will consume you.
Kai N.— Developer API marketplace
$8.9k MRR11mo in prod
KEPT
Unkey — API key management solved. Rate limiting, usage tracking, key rotation — all handled. We'd have spent a month building this ourselves.
Trigger.dev — Background jobs for API usage aggregation, billing calculations, and webhook deliveries. The v3 DX is incredible — just write async TypeScript.
Polar — Developer subscriptions without the Stripe overhead. MoR means we don't deal with tax compliance in 40 countries.
REPLACED
Custom API key system → Unkey — Our homegrown API key system had no rate limiting, no analytics, no rotation. Unkey added all three in one afternoon.
Stripe → Polar — Stripe Billing was $500/mo minimum for our usage patterns. Polar handles developer subscriptions natively at lower fees.
Regret: Didn't implement usage-based billing from the start. Switching from flat-rate to metered billing after 200 customers was a nightmare.
Advice: Use Unkey for API key management. Don't roll your own. And implement usage-based billing from day one — even if you start with flat rates, the metering infrastructure needs to exist.
Elena M.— AI-powered design tool
$11k MRR13mo in prod
KEPT
Cerebras — 2000+ tok/s on Llama 3.3. Our AI design suggestions appear as the user is still moving elements. It feels telepathic.
Convex — Real-time canvas state sync between collaborators. Every cursor, every element, every undo — synced in <50ms.
Vercel — Edge rendering for the marketing site + app. Global CDN means the app loads in <1s everywhere.
REPLACED
OpenAI → Cerebras — Design suggestions need to be instant. OpenAI at 80 tok/s felt laggy. Cerebras at 2000 tok/s makes AI feel native to the design workflow.
Supabase Realtime → Convex — Supabase Realtime had 200ms latency spikes under load. Convex is consistently <50ms. For a design tool, that difference is night and day.
Regret: Built the multiplayer cursor system from scratch before discovering Convex's presence API. Three weeks of work replaced by 10 lines of code.
Advice: For real-time collaborative apps, start with Convex. Build the hard parts (your actual product logic), not the infrastructure.
David C.— Open source CRM
$2.4k MRR8mo in prod
KEPT
Twenty — Forked Twenty for our vertical CRM. Open source base saved us 6 months of development. Customized the data model for real estate.
Coolify — Self-hosted PaaS on a €40/mo Hetzner box. Deploy Twenty, Postgres, Redis, and our custom services. Zero cloud bills.
Biome — Replaced ESLint + Prettier with zero config. Our CI went from 90 seconds to 3 seconds.
REPLACED
Salesforce → Twenty (self-hosted) — Salesforce was $75/user/mo. Twenty is free. For a 15-person real estate team, that's $13,500/year saved.
Heroku → Coolify on Hetzner — Heroku was $250/mo for what Hetzner + Coolify does for €40. Performance is better too.
Regret: Tried to build a CRM from scratch before discovering Twenty existed. Wasted 2 months on CRUD screens that Twenty already had.
Advice: Before building any business tool, check if there's an open source version. Twenty for CRM, Docmost for docs, Hoppscotch for API testing. Fork and customize — don't build from zero.
Nina R.— AI customer support agent
$28k MRR14mo in prod
KEPT
Groq — Customer support needs instant responses. Groq serves Llama 3.3 at 1200 tok/s. Our AI agent responds faster than human agents.
Inngest — Ticket processing pipeline: classify → route → draft response → human review → send. Each step is a separate Inngest function with automatic retries.
Neon — Serverless Postgres for multi-tenant ticket storage. Branch per customer for data isolation. Scale to zero between requests.
REPLACED
GPT-4o → Groq (Llama 3.3 70B) — GPT-4o for support classification: 80 tok/s, $0.005/1K output. Groq: 1200 tok/s, $0.0006/1K. Same accuracy for classification tasks.
AWS SQS + Lambda → Inngest — SQS + Lambda: 200 lines of CloudFormation YAML for each queue. Inngest: 20 lines of TypeScript. Same reliability, 10x less config.
Regret: Over-engineered the AI pipeline. Started with 4 models in sequence (classify → extract → draft → review). Simplified to 1 model call with structured output. Latency dropped 4x.
Advice: Start with one LLM call, not a pipeline. Add complexity only when you have data proving one call isn't enough. Most AI features need one good prompt, not an agent framework.
Marcus W.— Webhook delivery platform
$6.5k MRR9mo in prod
KEPT
Trigger.dev — Webhook retry logic with exponential backoff, dead letter queues, and delivery tracking. Trigger.dev v3 made this trivial.
Hono — Ingestion API handles 10k req/s on a single Cloudflare Worker. Sub-millisecond routing. Perfect for high-throughput webhook relay.
Upstash — Redis for delivery deduplication and rate limiting. Serverless = pay per command. Our idle hours cost $0.
REPLACED
Express on Railway → Hono on Cloudflare Workers — Express cold starts of 200ms were unacceptable for webhook ingestion. Hono on Workers: 0ms cold start, global edge.
Self-hosted Redis → Upstash — Redis on Railway was always-on ($7/mo minimum). Upstash: $0 when idle, pennies under load. Perfect for bursty webhook traffic.
Regret: Built custom retry logic before discovering Trigger.dev v3. Our retry system had bugs with backoff timing. Trigger.dev's is battle-tested.
Advice: For any async processing: Trigger.dev or Inngest. Custom queue/retry code is a maintenance nightmare. Let someone else handle the edge cases.
Leah F.— SaaS billing analytics
$4.7k MRR6mo in prod
KEPT
Polar — Our own billing runs on Polar. Developer-focused, clean API, and they handle tax filing as MoR. One less headache.
Neon — Serverless Postgres with branching. We create a branch per test suite run. Integration tests run against a real database, not mocks.
Better Auth — Auth with zero monthly cost. At our stage, every dollar saved extends runway. Better Auth is free forever.
REPLACED
Auth0 → Better Auth — Auth0's free tier was capped at 7k MAU. We hit it in month 3. Better Auth: unlimited users, self-hosted, $0.
PlanetScale → Neon — PlanetScale killed their free tier. Neon's free tier covers our current needs. And branching for testing is a killer feature.
Regret: Used Segment for analytics tracking before realizing PostHog does analytics + CDP in one tool. Paid for two services when one would do.
Advice: Check PostHog before buying separate analytics + CDP + feature flags. One tool, one bill, one integration. And it's open source so you can self-host if costs grow.
Chris K.— Open source monitoring tool
$1.9k MRR5mo in prod
KEPT
Coolify — Our entire stack runs on a single €40/mo Hetzner box. Coolify manages the deploys. We'd pay $400+/mo on Railway for the same setup.
Turso — Per-user SQLite databases at the edge. Each customer's monitoring data stays in their region. GDPR compliance by architecture.
Hono — API ingestion on Cloudflare Workers. 200+ regions, sub-millisecond cold starts. We compete with Datadog on latency for free.
REPLACED
Railway → Coolify on Hetzner — Railway was $87/mo for 3 services. Coolify + Hetzner CX31: €40/mo for 10 services. Same Docker, better price.
Supabase → Turso — Per-user Postgres instances were uneconomical on Supabase. Turso gives us per-user SQLite databases for pennies.
Regret: Started with a monolith on Railway before realizing our ingestion API needs edge deployment. Should have separated ingestion (Workers) from processing (Coolify) from day one.
Advice: For data-intensive products: separate ingestion (edge, stateless) from processing (your server, stateful). Hono on Workers for ingestion, Coolify on Hetzner for everything else.
Isabel G.— Developer newsletter platform
$9.3k MRR11mo in prod
KEPT
Resend — Email deliverability is our product. Resend's deliverability is consistently 99%+. React Email templates let us build beautiful emails in code.
Trigger.dev — Newsletter sends to 50k subscribers need retry, rate limiting, and progress tracking. Trigger.dev handles all three.
Langfuse — We use AI to generate subject lines and summaries. Langfuse tracks which prompts drive the highest open rates. Data-driven prompt engineering.
REPLACED
SendGrid → Resend — SendGrid deliverability was 85%. Emails hitting spam constantly. Resend: 99%+. Night and day difference for a newsletter product.
Custom queue (Redis + BullMQ) → Trigger.dev — BullMQ queue stalled at 10k emails. Trigger.dev scales without configuration. And the dashboard shows progress in real-time.
Regret: Built a custom email editor (took 2 months) before discovering React Email. Could have had a better editor in one week.
Advice: For email products: Resend + React Email. Don't build your own email rendering. And add Trigger.dev for any send over 1000 recipients.