Choosing a Stack
A decision framework for technology selection — team, scale, budget, hiring.
The Most Important Rule
The best stack is the one your team can execute in. It doesn't matter if Rust is technically superior if nobody on your team knows it. A team that ships with Python is better than a team that never ships with their perfect theoretical stack.
The 5-Step Decision Framework
Use this framework to choose a stack:
Step 1: What Are You Building?
Different projects have different needs:
- Blog/Content: Static site generator or CMS (Next.js, Hugo, WordPress)
- MVP/Prototype: Speed matters. Rails, Django, or Node.js
- Real-time App: Needs WebSockets. Node.js, Go, or Rust
- Data-Heavy App: Focus on analytics and databases. Python, Scala, or Go
- Performance-Critical: Rust, Go, or C++
- Consumer App: Think about scale from day one. Cloud-native stack.
Step 2: What Does Your Team Know?
This is the most important question. Existing expertise compounds:
- A team of Python experts will ship faster in Django than learning Node.js
- Ruby teams should use Rails
- JavaScript teams → Next.js or similar
- PHP teams → Laravel
Step 3: What's Your Scale Horizon?
Plan for growth, but don't over-engineer:
- Small startup (0–10K users): Monolith works fine. Focus on product.
- Growing (10K–1M users): Start thinking about scaling. Database optimization, caching.
- Massive scale (1M+ users): Microservices, distributed systems, specialized databases.
Step 4: What Are Your Hiring Constraints?
Can you hire people to maintain this stack?
- Large hiring pools: JavaScript, Python, Java, Go, PHP
- Smaller pools: Ruby, Elixir, Clojure, Rust (growing)
- Boutique tech: Haskell, OCaml, Lisp (very niche)
If you pick niche tech, be prepared to pay 50–100% premium salaries or struggle to find people.
Step 5: What's Your Budget and Timeline?
Bootstrap/Limited Budget: WordPress, shared hosting, Laravel, or Rails
Funded Startup: Next.js + TypeScript + Prisma + Tailwind. Modern tools with great DX.
Enterprise: Cloud-native (Kubernetes), proven tooling (Java Spring Boot, .NET Core)
The Stack Over-Engineering Trap
Many teams fall into this pattern:
- Choose a "sophisticated" stack because it's powerful
- Build infrastructure for scale you don't have yet
- Slow down shipping because setup is complex
- Eventually realize: you could have shipped faster with a simpler stack
Counter-intuitive truth: Simple stacks are fast. Complex stacks are slow. Pick simple unless you have a specific reason not to.
Start with a Monolith
A common mistake: building microservices from day one. Microservices solve operational complexity problems, not development complexity problems. They slow you down at small scale.
Better approach: Start with a monolith. A single codebase, single database, single deployment. Ship fast. When you have real scale problems (teams can't communicate, deployment conflicts, etc.), then split into services.
Future-Proofing Your Stack
How do you avoid choosing technology that becomes a liability?
- Community: Is it actively developed? Declining community = future liability
- Multiple Implementation: Languages are more stable than frameworks (Python > Django)
- Hiring Pool Size: Big hiring pools mean you're not betting on a niche
- Company Backing: Technology with major company backing is lower risk (React has Meta, Kubernetes has Google, etc.)
- Standard Patterns: Avoid bleeding-edge. Use proven, boring technology
Stack Recommendations by Use Case
| Use Case | Recommended Stack | Why |
|---|---|---|
| Blog/Content Site | Next.js + TypeScript + Tailwind (on Vercel) | Fast, static-friendly, great DX, simple deployment |
| MVP (funded startup) | T3 Stack or Next.js + Node.js | Modern, type-safe, all-in-one |
| Enterprise App | Java Spring Boot or .NET Core | Proven, stable, large hiring pool |
| Real-time App | Node.js + Socket.io or Go + Gorilla | Handle concurrency well |
| Data Pipeline | Python + Django or FastAPI | Excellent data ecosystem |
| E-commerce | Next.js or Shopify if early-stage | Performance-critical, need CDN, fast checkout |
| Mobile + Web | React Native + Node.js backend | Code sharing, same team |
| Rapid Prototyping | Rails or Django | Convention-driven, quick to feature-complete |
| High-Traffic API | Go or Rust | Performance and efficiency |
| Low-Budget Site | WordPress on shared hosting | Cheap, works |
Final Advice: Make a Decision and Move On
The worst thing you can do is waste months researching stacks and never build anything. Here's a decision tree:
- Does your team have strong experience in a language/framework? → Use it
- Are you funded? → Use modern, well-maintained tech (Next.js, Go, Python, etc.)
- Are you bootstrapped? → WordPress, Webflow, or a proven framework your team knows
- Is this a prototype? → Pick whatever you know fastest
- Will you hire for this? → Pick something with a large hiring pool
Once you've decided, commit. The stack you choose matters less than executing well in it.