You’ve got years of experience. You know what works. And yet everywhere you look there’s pressure to use React, Next.js, TypeScript for your next project.
Meanwhile Pieter Levels is pulling in $3 million a year using vanilla PHP, SQLite, and jQuery. Zero employees.
The gap between what works and what’s trendy has never been wider. If you’re looking for permission to choose the simpler stack—the boring one—you’re in the right place. We’re going to walk through the innovation tokens framework, show you actual velocity differences, and give you a decision framework for choosing proven technology over whatever’s currently fashionable.
What is the Boring Stack and Why Do Solo Founders Use It?
Boring technology is a strategic choice. You’re prioritising stability, known capabilities, and operational simplicity over novelty. PHP is boring. MySQL is boring. Postgres is boring. SQLite is boring. jQuery is boring.
These are mature tools. Well-understood. Proven track records. Documented failure modes.
When you’re solo you’re wearing every hat—developer, ops, support, marketing. No time for fighting frameworks or wrestling with infrastructure. When something breaks at 2am you need to know exactly where to look and how to fix it. Fast.
The velocity advantage kicks in immediately. Zero setup time. Spin up Apache/PHP on shared hosting in minutes. Deployment? Upload files. That’s it. Minimal operational overhead means you’re building features, not managing infrastructure.
Pieter Levels maintains seven products solo because every single one uses the same PHP/SQLite/jQuery stack. He copies patterns across products. Shares code between them. Deploys changes rapidly. Try doing that with multiple React/Next.js projects each with their own build configurations and deployment pipelines.
Compare that with modern stacks. React needs Node.js, build tools, state management libraries, and you’re constantly learning new ecosystem stuff. Framework just released a new version with breaking changes? Congratulations, you’ve got homework.
Dan McKinley coined the phrase “Choose Boring Technology” while at Etsy, watching the company drown in complexity from too many novel tools. The principle is simple: complexity kills solo operations. Boring stack eliminates accidental complexity so you can focus on building the actual product.
How Do Innovation Tokens Work for Technology Stack Decisions?
Here’s the framework that’ll change how you think about technology choices.
Every company gets about three innovation tokens to spend on unproven or novel technologies before operational complexity spirals out of control.
Choose to write your website in Node.js? That’s one token. MongoDB? Another token. Write your own database? You’re in trouble.
Each novel technology choice costs a token because you’re taking on unknown unknowns. You have to monitor it, figure out unit tests, understand failure modes, write init scripts. You’re investing cognitive overhead in becoming expert enough to keep it running.
Solo founders have it worse. You’ve actually got fewer than three tokens to spend because of the one-person constraint. When things go wrong—and they always do—you’re the entire response team.
Let’s count tokens for a typical modern stack. React costs one token if you’re not already expert. Next.js on top of React? Another token. TypeScript? That’s complexity and another token. State management library? You’re already over budget.
Compare that to PHP/Laravel. PHP costs zero tokens. It’s been around 30 years. Failure modes are well understood. Millions of Stack Overflow answers for every edge case you’ll encounter. Laravel is also zero tokens—proven MVC patterns, 10+ year track record.
The strategic question: where should you spend your limited tokens?
Photo AI generates $138K a month. One of Pieter Levels’ biggest revenue sources. He spends tokens on AI model integration—the differentiator customers actually pay for. He doesn’t waste tokens on React infrastructure, which is just commodity cost.
Dan McKinley put it perfectly: devoting any of your limited attention to innovating SSH is an excellent way to fail, or at best, delay success. Spend tokens on what makes you money, not on supporting infrastructure that just enables what makes you money.
This is the insight experienced developers need to hear: using boring technology is strategic resource allocation. You’re not being lazy. You’re not outdated. You’re being intentional about where you invest your limited operational capacity.
Why Does Boring Stack Maximise Development Velocity for Solo Operations?
Once you measure it honestly, the velocity difference is clear.
Setup time for PHP on shared hosting? Five minutes. Create account, upload files, done. Setup time for React/Next.js with proper deployment? Hours. Build tools, environment variables, deployment pipelines, hosting platforms. Hours.
Then there’s the build step. PHP and jQuery—write code, refresh browser. React—wait for webpack or vite to rebuild, watch for compilation errors, manage hot module replacement quirks.
Deployment matters when you’re shipping multiple products. PHP is FTP or rsync. Upload files, they’re live. React/Next.js needs Vercel configuration, PM2 process management, or Docker containers. Each step is another thing to debug at 2am.
The cognitive overhead compounds. With PHP you’re working in one language with a straightforward server model. Modern JavaScript stack? You’re juggling client-side JavaScript, server-side JavaScript, build configurations, package.json manifests, tsconfig files, framework-specific patterns. Then the framework updates and half your knowledge is deprecated.
Pieter Levels launched Photo AI in 2-3 weeks as an MVP. His deployment process? Make a small fix, Command + Enter sends to GitHub, webhook deploys to production. Done. No build step, no complex pipeline.
The 12 Startups in 12 Months methodology he pioneered needs maximum velocity. One new product every month. The lesson: volume matters. Ship more, learn faster. You can’t do that if setting up a new project takes a week.
Your productivity matters more than using the “best” technology. Master one stack deeply.
The copy-paste velocity multiplier is real for portfolio operators. When every product uses identical patterns you build a library of solutions you can deploy instantly. Framework version conflicts don’t exist because there are no frameworks.
Dependency hell avoidance saves you weeks per year. The npm ecosystem churns constantly. React 16 to 17 to 18 brought breaking changes. Next.js 12 to 13 to 14 each required migrations. PHP evolves, but it maintains backward compatibility religiously. Code written for PHP 5 mostly runs on PHP 8.
The metric that actually matters: time from empty directory to working feature deployed in production. Boring stack? Hours to days. Modern stack? Days to weeks just getting infrastructure configured correctly.
What Does the Actual Complexity Look Like: PHP vs React for the Same Feature?
Let’s compare the same feature in both stacks: user registration with email confirmation. Basic functionality every SaaS needs.
The complexity difference is measurable. PHP version? About 80 lines across one file. Use Laravel instead and you get MVC structure but still under 150 lines across three files.
The React version? 200+ lines across five or more files for equivalent functionality. Component files, API routes, client-side state management, validation integration, email service configuration, build tool setup. It all adds up.
Dependencies tell another story. PHP version needs Apache, PHP, and MySQL—pre-installed on most shared hosting. React version needs Node, npm, React itself, Next.js, a state management library, a validation library, an email service client, build tools, and about 50-100 other packages.
The PHP version works for years untouched. The React version? Weekly dependency updates. Framework migrations every year or two. That moment when a minor version breaks your production build.
Time measurement: PHP implementation takes about 2 hours including testing. React implementation takes 6-8 hours with all the setup, configuration, and debugging.
When does React win? Real-time features. Complex UI state with dozens of interactive components. Offline functionality. For standard CRUD applications with form submission and basic interactivity, React is overhead with no benefit.
How Does the Lindy Effect Apply to Technology Stack Choices?
The Lindy Effect is simple: for non-perishable things, future life expectancy is proportional to current age. Something that’s existed for a while is very likely to keep existing for just as long.
PHP has been around 30 years since 1995. Under the Lindy Effect, it’s likely to persist another 30 years. The installed base is substantial. WordPress powers 43% of all websites. Facebook‘s backend is PHP. Laravel has thousands of SaaS businesses built on it.
React is 11 years old, released in 2013. Already seen major breaking changes and migration cycles. Its future depends on Meta‘s priorities, which shift.
Betting on PHP means you have an established ecosystem. Extensive documentation. Millions of answered Stack Overflow questions. Every edge case has been encountered.
jQuery is the perfect Lindy Effect example. Developers have been declaring it “dead” since 2015. And yet jQuery still powers 77% of websites in 2025 according to W3Techs.
Why? Because it works. It’s boring. Everyone knows how to use it. Documentation is complete. Edge cases are handled. And most websites don’t need reactive UI frameworks—they need DOM manipulation and AJAX calls.
The framework graveyard provides lessons. Angular.js was the future, then Angular replaced it. Backbone.js powered serious applications, now it’s a museum piece. Ember.js was going to win. It didn’t.
When you’re solo you can’t afford to rewrite your stack every 3-5 years when framework momentum shifts.
PHP gets declared dead every few years—2008, 2012, 2016, 2020—yet it keeps thriving. That’s Lindy Effect proving itself.
What Are the Real Infrastructure Costs: PHP/SQLite vs React/Next.js/PostgreSQL?
The cost difference compounds quickly when you’re running multiple products.
Shared PHP hosting costs $5-10/month and supports unlimited sites. Vercel or Heroku for a React/Next.js app costs $20-100/month per project. Right there you’ve got a 10x difference before you even consider database costs.
SQLite is free and file-based. PostgreSQL managed service costs $15-50/month minimum. For what? SQLite handles millions of requests. Nomad List at $3M/year revenue scale proves this is viable.
CDN and build costs are mostly invisible with PHP. Next.js with edge functions gets expensive on Vercel at scale.
Pieter Levels’ actual costs demonstrate the economics. Total monthly spend? About $13K. But $12K is Replicate API for AI processing—the actual product differentiator. VPS hosting? $40/month. His profit margin is 87%+.
Compare that to typical React stack costs. Vercel hosting: $500+/month. PostgreSQL: $100+/month. CDN: $50+/month. Monitoring: $50+/month. You’re at $700/month minimum before AI costs. Multiply by seven products and the difference becomes substantial.
Portfolio multiplication effect: boring stack costs don’t scale linearly with product count. One VPS runs multiple PHP applications. One MySQL instance hosts dozens of databases. The marginal cost of the eighth product is near zero.
When should you graduate from SQLite to PostgreSQL? When you hit high concurrent writes—more than 1,000 simultaneous write operations. When you need advanced features like full-text search at scale or complex replication. Don’t migrate prematurely because “real databases use PostgreSQL.” SQLite is real, boring, and sufficient for most products.
How Should You Evaluate PHP vs React for Your Team Context?
Here’s the decision framework: business stage, team size, innovation token budget, existing expertise, and operational capacity.
Solo founders should default to boring stack unless your specific product requires React. Real-time collaboration tools need React. Offline-first applications need React. Complex UI state with dozens of interactive components needs React. Standard CRUD applications with forms and basic interactivity? Boring stack wins.
Small teams of 2-5 developers should still favour boring stack. Spend your innovation token budget on business logic and product differentiation, not infrastructure.
Growing teams of 5-15 can consider React if the hiring pool demands it, but Laravel remains viable. The question isn’t “what’s technically possible” but “what ships features fastest with our specific team.”
Inheriting an over-engineered React stack? You can justify simplification. Count the innovation tokens being spent. Ask: does this complexity enable revenue or just support it?
When React is correct: large frontend teams that specialise in UI work. Complex SPA requirements needing sophisticated client-side state. Existing React expertise you’re leveraging.
Startups that must ship fast to find product-market fit? Boring stack. Well-funded teams optimising for scale at 100x current size can afford to spend tokens on sophisticated infrastructure.
Don’t choose stack based on what developers want to learn. Choose what ships products. Resume-driven development is real, and it’s expensive.
FAQ
Can you really build a profitable business with PHP in 2025?
Yes. Abundantly proven. Successful solo founders generate substantial revenue with vanilla PHP and SQLite across multiple products. WordPress powers 43% of all websites. Laravel ecosystem is thriving with companies like Forge, Vapor, and thousands of SaaS businesses. PHP 8.x is modern, performant, and actively developed. The question reveals bias toward framework hype over business results.
Is it okay to use jQuery instead of React for my startup?
If your product doesn’t require complex SPA features like real-time updates, offline functionality, or intricate UI state, jQuery is completely viable and ships faster. Successful founders use jQuery for multi-million dollar products. The 77% of websites still using jQuery (W3Techs 2025) aren’t wrong—they’re being pragmatic. Use React when it solves actual problems, not because it’s fashionable.
How do I convince my team to use boring technology when they want React?
Reframe the conversation around innovation tokens and business outcomes. Ask: will React directly make us money or enable features customers will pay for? If no, it’s spending tokens on infrastructure instead of differentiation. Show velocity comparisons—time to ship features matters more than resume-driven development.
What’s the actual difference in development speed between boring stack and modern frameworks?
For solo founders and small teams: boring stack is typically 2-3x faster for MVPs and standard CRUD features. Setup time is minutes versus hours. Deployment is file upload versus complex pipeline. Maintenance is stable platform versus constant framework updates. Weekend MVP is possible with PHP/SQLite but takes weeks with React/Next.js/PostgreSQL setup.
When should I graduate from SQLite to PostgreSQL?
SQLite handles substantial scale. Migrate when you hit: 1) High concurrent writes (more than 1,000 simultaneous), 2) Need for advanced features like full-text search at scale or complex replication, 3) Team prefers SQL database for collaboration. Don’t migrate prematurely because “real databases use PostgreSQL.” SQLite is real, boring, and sufficient for most products.
Why would anyone use PHP when everyone says it’s dead?
PHP powers 76% of all websites with known server-side languages (W3Techs 2025). “Everyone” is developers on Twitter, not businesses shipping products. PHP 8.x is modern, performant, and actively developed. Laravel is thriving. WordPress isn’t disappearing. The “PHP is dead” narrative has repeated since 2008 yet PHP persists—Lindy effect in action. Solo founders care about velocity and profit, not developer sentiment.
How does boring stack enable the portfolio approach for solo founders?
Simple stack lets you operate multiple products without proportional complexity increase. Founders maintain multiple products solo because each uses an identical simple stack—they can copy patterns, share code, deploy rapidly. Modern stack complexity means each new product requires significant setup and maintenance overhead. Portfolio approach needs maximum reusability and minimum operational toil—boring stack delivers both. This technical foundation is essential to building profitable SaaS without VC funding, where operational efficiency directly impacts profitability.
Should I choose boring technology or follow modern best practices?
“Best practices” are context-dependent. For solo founders and small teams, boring stack is best practice because it maximises velocity and minimises operational overhead. For large teams building complex SPAs, React might be best practice. The question assumes modern equals better, but boring technology won selection through decades of production use. Follow practices that ship products profitably, not practices that look good on developer Twitter.
What if I need AI features—doesn’t that require modern stack?
No. You can generate substantial revenue using boring PHP/SQLite backend calling AI APIs. Spend innovation tokens on AI model integration (differentiator), not on React/Next.js infrastructure (commodity). Laravel has excellent API client support. Most AI services are API-based—language choice for calling APIs is irrelevant. Boring backend with AI features is optimal: known infrastructure, novel product capability.
How do you decide when to simplify your tech stack?
Count innovation tokens being spent on non-differentiating technology. If you’re drowning in operational complexity—Kubernetes, microservices, React framework updates—but not shipping features faster, you’re over-indexed on infrastructure. Ask: does this complexity enable revenue or just support it? Boring stack frees capacity for actual product development.
Is Laravel a boring technology or does it spend innovation tokens?
Laravel is boring. It’s built on PHP (mature), follows proven MVC patterns, has a 10+ year track record, and extensive ecosystem. Using Laravel costs zero innovation tokens—it’s established, well-documented, with large community. It’s middle ground between vanilla PHP simplicity and React complexity. Appropriate choice for solo founders wanting framework benefits without modern stack complexity.
What about hiring—can I find PHP developers or only React developers?
PHP developers exist in abundance, often at lower rates than React specialists. Laravel community is active and growing. WordPress developers are everywhere. React developers are more common in startup hubs but less stable (job-hop frequently) and more expensive. PHP developers tend to be pragmatic, experienced, and stable. For solo founders, hiring isn’t the primary concern—you’re building solo. For small teams, finding one good Laravel developer beats hiring three junior React developers.
