Skip to main content

The Default Stack

At Inflection, our default stack for web applications and APIs was: That gave us a single language across the app and API, a relational database for companies and deals, and a deployment a solo engineer could maintain. If you inherit a working stack, keep using it. The cost of a rewrite comes out of the same budget as the next tool your partners need.

Why that stack worked for us

Velocity matters more than performance. You’re building tools for tens of users, not millions. A research platform that loads in 200ms versus 50ms makes no difference to a GP. But a research platform that exists in 2 weeks versus 2 months makes a huge difference to whether you get support for the next project. Maintenance matters more than elegance. You’ll be maintaining this code, probably alone, for years. The clever architecture that seemed smart when you built it becomes a nightmare when you’re the only person who understands it. Boring, well-documented, widely-used technology means you can fix things quickly and onboard others if your team grows. Integration matters more than custom solutions. VC funds live in an ecosystem of specific tools: Attio or Affinity for CRM, PitchBook for data, Harmonic or Specter for sourcing. Choosing technology that makes API integrations easy is more valuable than choosing technology that’s theoretically more powerful. Next.js gives you full-stack in one framework. You can build UI, API endpoints, background jobs, and webhooks all in the same codebase. For a research platform or sourcing tool, this means you don’t need separate frontend and backend repos, separate deployments, or coordination between different frameworks. One codebase, one deployment, less complexity. TypeScript catches errors before they reach users. When you’re shipping fast with limited testing, static typing is your safety net. The compiler catches bugs that would otherwise break production. And with modern AI coding tools, TypeScript’s explicitness helps Claude Code understand your codebase and generate correct code. shadcn/ui provides good-enough UI components. VCs aren’t evaluating your tools based on design polish. They care about functionality and insights. Shadcn gives you professional-looking components that work well without hiring a designer. Your GPs will never complain that you used shadcn/ui instead of a custom design system. Postgres is the right database for most VC tools. It’s relational (your data is structured: companies, deals, people, relationships), it’s mature, it scales far beyond what you’ll need, and as covered in Data Warehousing, it’s adequate as a data warehouse for small to mid-size funds before you need Snowflake or BigQuery. AI SDK makes LLM integration trivial. Most tools you build will use LLMs for something: summarizing companies, analyzing research, answering questions. Vercel’s AI SDK handles streaming, function calling, and failover between providers. You focus on prompts and features, not plumbing. AI coding agents work best with this stack. Next.js and TypeScript are among the most popular technologies developers use. This means Claude Code, Cursor, and Copilot have seen enormous amounts of training data with these frameworks. They generate better code, make fewer mistakes, and help you ship faster than if you chose something obscure.

When to Introduce New Technology

For Kepler (Inflection’s research platform), we introduced Tiptap to create a Notion-like editing experience. This made sense because:
  • The editing experience was core to the product’s value
  • Tiptap is mature, well-funded, and widely used
  • It integrated cleanly with React/Next.js
  • It solved a problem the default stack didn’t address
We didn’t also introduce a new database, a new deployment platform, a new state management library, and a new UI framework. We changed one thing where it mattered. Evaluate new technology with these questions:
  1. Does the default stack actually not solve this? Often you can build what you need with what you already have. Don’t add complexity for marginal improvements.
  2. Is this technology mature and well-maintained? Check recent commits, number of contributors, whether there’s a company behind it or just a solo maintainer. You don’t want to adopt something that will be abandoned in 6 months.
  3. Does it have financial backing? If it’s open source, is there a company funding development? If it’s proprietary, is the company sustainable? Switching technologies later is expensive.
  4. Does it integrate well with your existing stack? Adding a Python-based tool to an otherwise TypeScript codebase creates friction. Not insurmountable, but adds complexity.
  5. Will AI coding agents understand it? Obscure libraries mean Claude Code can’t help you as effectively. Popular libraries mean you ship faster.

When Python Makes Sense

Data analysis and exploration. When a GP asks “how many Series A companies in fintech raised in the last 6 months?”, you open a Jupyter or Hex notebook, write SQL to pull data from your warehouse, and use pandas to analyze it. Python notebooks are the standard for ad-hoc data work. TypeScript isn’t competitive here. Data transformations in the warehouse. If you’re using dbt for data transformations (covered in Data Warehousing), you’ll write Python for custom models that run in Snowpark (Snowflake), BigQuery DataFrames, or PySpark. The data warehouse ecosystem is Python-native. Machine learning and AI work. If you’re building anything involving model training, embeddings, or scientific computing, Python’s ecosystem (scikit-learn, numpy, PyTorch) is unmatched. Our approach: TypeScript by default for everything. Python when you genuinely need it for data work. That’s two stacks total: web stack (TypeScript/Next.js) and data stack (Python). Don’t add a third unless you have an exceptional reason.

Existing Code: Don’t Rewrite Unless It’s Broken

A common scenario: you join a VC fund that already has tools built by someone who left. The code is in a different stack than you’d choose. It’s not documented well. It’s not how you’d architect it. Your first instinct is to rewrite it in your preferred stack. If the existing tools work and serve GPs well, continue building on them. Your first job isn’t to rip everything out and start fresh. It’s to understand what the fund needs, fix what’s broken, and add value incrementally. Only rewrite existing code if:
  • It’s blocking new features. The architecture is so inflexible that you can’t add what GPs need without a rewrite.
  • It’s unmaintainable. The code is so poorly structured or undocumented that fixing bugs takes weeks instead of hours.
  • It’s actively broken. The tools don’t work, GPs don’t use them, and fixing them would take longer than rebuilding.
If you do rewrite, do it incrementally. Don’t announce “I’m rewriting everything, it’ll be ready in 3 months.” Build the new version alongside the old one, migrate features one by one, and deprecate the old system only when the new one is proven. This keeps GPs working while you improve infrastructure.

Lean on Managed Services

For hosting: Vercel for Next.js apps. Railway, Render, or Fly.io for other services. These platforms handle deployment, scaling, monitoring, and uptime. You push code, they run it. The alternative is configuring AWS infrastructure, managing Docker containers, setting up CI/CD, monitoring servers, and handling incidents. Not worth your time. For databases: Neon, Supabase, or PlanetScale for Postgres. AWS RDS if you’re already committed to AWS. Don’t run your own database servers. Let someone else handle backups, replication, and uptime. For background jobs: If you need async task processing, use a managed service like Trigger.dev, Inngest, Vercel’s workflow SDK rather than running your own job queue infrastructure. For monitoring: Use Vercel’s built-in monitoring or services like Sentry for error tracking. Don’t build your own observability stack. Compare the hosting bill with the time you spend patching services or recovering a failed job. For a small team, a few hours of maintenance each month can outweigh the saving from self-hosting. Put a number on the trade-off with your own costs. If managing a database takes four hours a month, multiply that by the fully loaded hourly cost of the person doing it. Add what happens when those four hours fall in the week before LP reporting. That’s the comparison to make when a managed service looks expensive on the cloud invoice. The exception: If you have specific compliance requirements (Security and Compliance covers security and compliance), you might need self-hosted infrastructure for data residency or audit reasons. But this is rare for most funds and work with your CISO or compliance officer to find a path forward. Default to managed services.

Dependencies: Be Selective But Not Afraid

In the VC ecosystem, you’ll use vendor SDKs and integrations:
  • API wrappers from your data providers
  • Vercel AI SDK for LLM integrations
  • Drizzle or Prisma for database access
These are core dependencies that make sense. They’re maintained by companies who have financial incentive to keep them working, and they save you from writing API integration code from scratch. Libraries worth keeping:
  • A well-maintained date library (date-fns) saves time and reduces bugs
  • A validation library (Zod for TypeScript, covered in Integrations and APIs) is essential for API integrations
  • A testing library (Vitest) makes sense if you write tests (though for internal tools, extensive testing is often overkill)
Be wary of:
  • Dependencies that do things you could write in 10 lines of code (micro-dependencies)
  • Dependencies with no recent commits or single maintainers
  • Dependencies that pull in huge transitive dependency trees
For framework-specific conventions, skills.sh has working examples, including Vercel’s React best practices and Supabase’s Postgres best practices. Emerging Trends covers turning your own recurring tasks into skills.