Founder Tools We Use Daily

The Short List (Read This First)

If you want nothing but the answer: here are the tools we’d be genuinely stuck without.

1. Cursor — AI coding editor. We’re faster in it than anything else, period.
2. Anthropic API + OpenAI API — core LLM calls. Claude for reasoning and long context, GPT-4o for speed-sensitive paths.
3. PostHog — product analytics, session replay, feature flags, all in one. Free until you scale.
4. Railway — deployment. Ships in minutes, doesn’t require a DevOps hire.
5. Sentry — error tracking. We know about bugs before users report them.
6. Linear — issue tracking. The only project management tool that doesn’t feel like homework.

Everything else below is real and earns daily use, but those six are the ones that, if they went away tomorrow, we’d scramble.

AI Coding: Cursor

Cursor is the editor we use. Not VS Code with Copilot. Not Windsurf. Cursor.

The reason is simple: the tab completion is better, the inline editing is faster, and the multi-file context handling is actually useful in a real codebase. GitHub Copilot is fine — it’s what you use when you’re on a team that hasn’t migrated yet. Cursor is what you use when you’re moving fast and the editor needs to keep up.

The workflow that actually matters: write a quick comment or docstring explaining what you want, hit tab, review the suggestion, accept the 80% that’s right, fix the rest. On boilerplate-heavy work — writing API routes, test cases, TypeScript interfaces — the speedup is probably 3-4x. On novel logic, it’s more like 1.2x. That’s still meaningful when you’re shipping every day.

What we use it for: Everything. Python backend, TypeScript frontend, writing config files, refactoring, generating test scaffolding.

Cursor vs. alternatives:

• GitHub Copilot: fine if your team is on it already. The autocomplete lags more, the multi-file context is weaker. Not worth switching away from Cursor once you’ve been in it.
• Windsurf (now Devin Desktop): solid, more agent-forward, but was acquired by Cognition AI in late 2025 and rebranded as Devin Desktop. We haven’t switched because Cursor’s baseline is already high.
• Claude Code (Anthropic’s CLI): this one is genuinely complementary, not a replacement. We use it for larger refactors, migrations, and anything that needs a conversation about architecture. It’s not an editor; it’s a coding agent you talk to.

Cost: Cursor Pro is $20/month. Best $20 we spend.

Gotcha: The AI sometimes confidently generates code that looks right but subtly isn’t — especially on library APIs it’s not fully current on. You still have to read what it writes. The editor makes you faster; it doesn’t make you less responsible for the code.

LLM APIs: Anthropic + OpenAI

For the product itself (not our editor), we use both.

Anthropic (Claude) is our default for anything that involves: long documents, structured reasoning over complex inputs, tasks where getting it subtly wrong is expensive, or long context windows. Claude Sonnet is the right model for most of what we do — Opus for things we really need to get right, Haiku when cost and latency matter more than quality.

OpenAI (GPT-4o) is what we reach for when: we need faster time-to-first-token, the task is well-defined and shorter, or we’re integrating with tooling that’s more OpenAI-native. GPT-4o-mini is excellent for cheap, fast classification and preprocessing tasks.

We don’t use a single provider out of loyalty. We use each where it wins. In practice, for a startup building AI features: start with Anthropic Sonnet for most things, use GPT-4o-mini for high-volume low-stakes inference, and benchmark your specific task if cost matters at scale.

Cost reality check:

• Claude Sonnet 4: ~$3 / 1M input, ~$15 / 1M output
• GPT-4o: ~$2.50 / 1M input, ~$10 / 1M output
• GPT-4o-mini: ~$0.15 / 1M input, ~$0.60 / 1M output

Until you’re doing real volume, the difference between providers is noise. At scale, profile your actual token usage first — output tokens are where costs bite.

Gotcha: Don’t architect your product to be provider-specific. Thin wrappers around the OpenAI SDK work fine for now, but the field is moving fast enough that you want the ability to swap models without a major rewrite.

Product Analytics: PostHog

PostHog is what we use instead of Mixpanel, Amplitude, and Hotjar combined. That’s the pitch — it does all three things in one product. In practice: event analytics, funnels, session replay, feature flags, A/B testing, and surveys.

For an early-stage startup this is the right call. You don’t want three tools with different auth systems, different data models, and separate bills. PostHog gives you a unified view of what users do and why, without needing a data team to stitch it together.

What we use it for daily: Session replays when a user reports something confusing (“can you share what happened?” is no longer required — we just watch). Funnel analysis for onboarding. Feature flags for rolling out new capabilities to segments. Event tracking for the product metrics our weekly reviews run off of.

PostHog vs. alternatives:

• Mixpanel: excellent analytics product, but you’re paying separately and giving up replay and flags.
• Amplitude: more powerful at scale, overkill until you have a data analyst to get value from it.
• Hotjar: great for session replay, that’s all it does. PostHog’s replay is 80% as good and you’re already in PostHog.
• Segment: useful as a CDP layer if you’re sending data to many downstream tools. Not what you need at early stage.

Cost: Free up to 1M events/month and 5K session recordings. That’s more than enough to learn from your first thousand users. Self-hostable if you want zero cost and full data control — the open source version is real and actively maintained.

Gotcha: Event naming discipline matters. If you instrument sloppily in month one, you’ll spend a week cleaning it up in month six. Pick a naming convention (noun_verb, e.g. document_created) and stick to it.

Customer Communication: Intercom

Intercom is expensive. It’s also the right answer for an early-stage B2B or prosumer SaaS if you can afford it.

Why Intercom over the alternatives: it combines live chat, in-product messaging, email sequences, and a support inbox in one place. The user identity layer (tying conversations to the same user you see in PostHog) is genuinely valuable. The AI-assisted support features have gotten good enough to handle a real percentage of inbound without a human.

What we use it for: onboarding sequences triggered on product events, support chat, and keeping a paper trail of every conversation with every user. When a user upgrades or churns, there’s a conversation thread with context. That’s worth a lot.

Intercom vs. alternatives:

• Crisp: solid free/cheap tier. Good if you need live chat and basic sequences without the Intercom bill. We’ve used it — it works. You’ll outgrow it.
• Loops: excellent for email sequences for developer-focused products. We use this for email marketing; it’s not a support tool.
• Plain: newer, more developer-native support tool. Worth watching if Intercom’s cost is prohibitive.
• Zendesk: too heavyweight for early stage. Built for support orgs, not small founding teams.

Cost: Intercom pricing has moved around but expect roughly $85-$140/month per seat for the useful tier (Advanced plan). It’s one of those tools where you grit your teeth at the bill and renew anyway because switching has a real cost.

Gotcha: Don’t blast users with Intercom messages just because you can. The behavioral trigger system is powerful — use it surgically (e.g., message users who hit an error state, not every user who signed up).

Internal Tooling: Supabase + Retool

For internal dashboards and ops tooling, we don’t build custom admin panels anymore. We use Supabase’s built-in table editor and views for quick data access, and Retool when we need something with actual UI.

Supabase: If your backend is Postgres (which it probably should be), Supabase gives you a hosted database with a pretty decent UI, row-level security, and auth baked in. The table viewer isn’t beautiful but it means your non-technical cofounder can look up user records without needing a SQL client.

Retool: When you need a real internal tool — a customer lookup page, a manual override UI, a support dashboard — Retool gets you there in hours. Connect it to your database or API, drag together a form and a table, done. We don’t use it every day, but every two weeks something comes up where it’s the fastest path.

Metabase is the other option we’ve used and liked for analytics-style internal reporting (charts, scheduled reports, sharing dashboards with non-technical stakeholders). If your data questions are more “how many users did X this week” than “update this record manually,” Metabase fits better.

Cost: Supabase free tier is generous. Retool free tier covers most internal tool use cases. Metabase is open source and self-hostable.

Payments: Stripe

Stripe is the answer. Not Paddle, not Lemon Squeezy, not a custom integration. Stripe.

The API is mature, the documentation is the best in the business, and every edge case you’ll hit — trials, proration, metered billing, discount codes, tax — has been solved in Stripe already. The cost (2.9% + $0.30 per transaction) is what it is. You’re not going to do better with the reliability and feature set you need.

What makes Stripe less painful:

• Stripe Billing portal: let users manage their own subscriptions. Do not build this yourself.
• Stripe webhooks + a queue: don’t process payment events synchronously. Put them in a queue (even just a simple Postgres-backed job queue) and process async. You will have webhook delivery failures; plan for idempotency from day one.
• Stripe Tax: automatic tax calculation across jurisdictions. It’s an add-on but worth it once you have international users.

Stripe vs. alternatives:

• Paddle: handles merchant-of-record tax obligations for you, which is genuinely valuable if international sales tax is painful. Tradeoff: less flexible API, slightly more opaque.
• Lemon Squeezy: same merchant-of-record angle, aimed at indie developers and smaller products. Fine for simple pricing; gets awkward with complex billing models.

If your pricing is simple and you’re early, Stripe is the call. If international tax compliance is your primary problem, Paddle is worth the API tradeoffs.

Gotcha: Implement idempotency keys on all Stripe API calls. Read the webhook handling docs before you think you’ve understood them.

Error Tracking: Sentry

Sentry. This isn’t a debate.

Install it on day one of your product. The ten-minute setup cost pays for itself the first time you get a JavaScript error report before any user files a support ticket. Sentry catches, groups, deduplicates, and routes errors. It integrates with Linear so you can turn an error into an issue without leaving your browser.

What we actually get from it: frontend error grouping, backend exception tracking with full stack traces, performance monitoring on slow API calls, and the weekly digest that tells us what’s actually breaking in production.

Cost: Free tier covers 5K errors/month. Enough to get started. Paid tiers are reasonable.

Gotcha: Configure your alert thresholds or you’ll get Sentry emails for every single occurrence of everything. Set up issue assignment and routing early.

Deployment: Railway

For web services, APIs, background workers, and cron jobs, we use Railway. Not Vercel (for backends), not Render, not ECS.

Railway’s value proposition: you push code, it deploys. The internal networking, environment variables, database provisioning, and logging are all handled through a UI that doesn’t require a DevOps background to understand. You can run a Postgres database, a Redis instance, a Python API, and a Node worker — all wired together — in about thirty minutes.

Deployment decisions in practice:

• Static sites and Next.js frontends: Vercel. It’s built for this. Edge network, previews per branch, zero-config. Nothing touches it for this use case.
• Backend APIs, workers, scheduled jobs: Railway. Fast, cheap, flexible.
• Heavy compute or ML serving: Modal or Fly.io depending on the workload. Railway isn’t the answer for GPU inference or large memory jobs.
• Render: a solid Railway alternative. We’ve used both; Railway’s DX is slightly better, Render has more predictable pricing.

Cost: Railway’s Hobby plan is $5/month. Usage-based beyond that. For an early-stage product, total hosting costs are often under $50/month.

Gotcha: Railway’s free tier has cold starts. Move to a paid plan as soon as you have real users — you don’t want a 30-second cold start on your first investor demo.

Design: Figma + v0

Figma is the default for UI design. If your product has a UI and you have any design work happening, Figma is where it lives. Collaborative, browser-based, integrates with everything.

For quick prototypes and throwaway UIs, we’ve added v0 (by Vercel) to the workflow. Describe a component or screen in plain language, get React code back. It’s not a replacement for real design — the output is often generic and needs polish — but for internal tools, quick experiments, and “I need to show this to a user tomorrow,” it’s the fastest path from idea to something that looks like a product.

What we don’t do: we don’t use Figma to spec every single thing before we build. For a startup, high-fidelity mocks before code is often wasted motion. Figma is most valuable for: complex multi-screen flows, design system components, and anything that needs to go in front of users for feedback.

Project Management: Linear

Linear for issues and tasks. Notion for knowledge and documentation. That’s the split.

Linear is the best project management tool for engineering teams, and it’s not close. Fast, keyboard-driven, good triage UX, sensible cycles/milestones model. The GitHub integration (linking issues to PRs, auto-closing on merge) is tight enough that we actually use it.

Notion is where we put everything that isn’t a task: runbooks, architecture decisions, competitive research, onboarding docs. It’s flexible to the point of being occasionally overwhelming, but it works.

What we don’t use:

• Jira: overkill for small teams, the UX hasn’t aged well.
• Asana/Monday: fine for non-technical ops, not how engineering teams think.
• Confluence: see Jira.

Cost: Linear free tier is sufficient for small teams. Notion free tier works until you need advanced features or lots of members.

Marketing and Distribution

For developer-focused products, most traditional marketing channels underperform. What actually works:

Loops for email marketing. Built specifically for SaaS, developer-friendly, cleaner than Mailchimp, better onboarding sequence tooling than most alternatives.

Twitter/X is still the best channel for reaching developers and founders directly. Especially for thought leadership, launch announcements, and building in public. Uncomfortable truth: it works, especially for early-stage discovery.

Changelog posts as distribution. Every non-trivial product update gets a short post. Existing users come back; potential users discover you through search. This is free and compounding.

Hacker News Show HN for launches. Still the best single-event distribution channel for developer products if your timing and framing are right. Prepare for the comments.

Minimal paid advertising until PMF. Paid acquisition before you know what message converts is expensive learning. Talk to users first, advertise later.

The Honest Total

All in, the tools above cost a small startup somewhere between $150 and $400/month depending on tiers and usage. That’s not nothing for a pre-revenue company, but it’s reasonable for the operational surface area they cover. The ones with meaningful free tiers (PostHog, Sentry, Railway, Linear, Notion, Supabase) mean you can actually run on close to zero until you have paying customers.

What we’ve cut over time: too many SaaS dashboards, overlapping analytics tools, anything that required a weekly login to justify the subscription. The list above isn’t aspirational — it’s what’s open in browser tabs right now.

If you’re building an AI startup and want to talk tools, architecture, or what’s actually working: the contact is on this site.