Technology Choices

Why We Don’t Use Node.js, React, etc

This document explains the reasoning behind our technology choices. It is not a manifesto or a critique of developers who use these tools—in many contexts, they are the right choice. But for our projects, they are consistently the wrong one, and this document explains why.

Note: This is not dogma. We use the right tool for the job. We run a proper database on our auth server, for example, because user authentication genuinely requires it. The decisions below are pragmatic, not ideological.

1. Users Pay for Every Megabyte

Our primary audience lives in developing countries—rural Africa, Southeast Asia, and parts of South America—where mobile data costs $1–3 per gigabyte and connections are slow and unreliable.

A standard React application ships 100–300KB of JavaScript before it renders a single pixel of useful content. For our users, that is not an inconvenience; it is a real financial cost and often means the site simply doesn’t load.

Our rule of thumb: If the total page weight (HTML + CSS + JS) exceeds 200 KB gzipped, we have already failed our users.

2. Old Devices Must Work

Budget Android phones with 512MB RAM, outdated browser engines, and slow CPUs are common among our users. Modern JavaScript frameworks assume a capable JS runtime. Our sites must not.

We build with progressive enhancement: the page works in plain HTML, CSS adds visual improvement, and JavaScript adds convenience—never core functionality. This is structurally incompatible with JS-first frameworks like React, which render nothing until the JS bundle executes.

3. Dependency Hell Is Real

We have experienced this directly. Our chat bots were originally written in Node.js and were migrated to Python specifically to eliminate dependency issues. That is not a theoretical concern—it happened on this project.

The npm ecosystem compounds this problem at scale. A “fairly simple” project can easily pull in 1,200+ packages, totaling half a gigabyte. Each of those packages is:

  • A potential source of breakage when versions conflict
  • A maintenance burden when security patches are needed
  • A thing that can simply stop working without warning

Plain HTML, CSS, and PHP have no dependency tree. There is nothing to break.

4. Supply Chain Attacks

Every npm package you install is code written by a stranger, running with full access to your build environment—and sometimes your users’ browsers. This is not hypothetical. A well-documented example of how this attack surface works in practice: https://www.youtube.com/watch?v=r5U4S0uUIVk

Projects with hundreds of transitive dependencies have a correspondingly large attack surface. Zero dependencies means zero third-party attack surface.

5. Static Files Are Faster and Cheaper to Serve

We pre-generate HTML at build time rather than assembling it on every page request. The difference matters:

Our approach (build-time): The Server receives the request and sends the complete HTML file → done. Zero processing, zero database queries, instant delivery.

Framework approach (runtime): Server receives request → executes framework → queries database → assembles template → sends response. Every visitor pays the processing cost individually.

For a user in rural Kenya on a 3G connection, this difference is measurable in seconds.

6. Node.js Requires Node.js

This sounds obvious, but it has real implications. Our sites run on cheap shared hosting—the kind of hosting our own users at satoshihost.com would actually use. Shared hosts almost universally support PHP. Very few support Node.js, and those that do charge more for it.

By using PHP and static files, our build process is portable to any server anywhere.

7. Long-Term Durability

A plain HTML file written in 2010 still works in every browser today. React applications from 2018 frequently cannot even be built anymore: breaking changes between major versions (class components → hooks → server components → etc.) mean the framework churn never stops.

We are a small team. We cannot afford to spend time on framework migrations. Our code should still work in five years without intervention.

8. Honest, Auditable Code

With static HTML and vanilla JS, anyone can view source and see exactly what the page does. A compiled React application shows transpiled, minified output that reveals nothing useful.

This matters for trust, for debugging, and for contributor accessibility. Plain HTML/CSS/PHP can be read and edited by almost anyone. The Node ecosystem requires substantial tooling knowledge before you can even run a project locally.

9. Security Surface Area

Fewer moving parts means fewer things to exploit. Every framework, every package, every build tool is a potential vulnerability. Our sites have no build pipeline in production—there is nothing to compromise between the editor and the served file.

When We Do Use Heavier Tools

The above reasoning applies to our public-facing sites. Where the use case genuinely justifies it, we use appropriate tools:

  • Database: Our auth server uses a proper relational database because authentication state genuinely requires it. Flat files would be the wrong choice there.
  • Python: Our chat bots use Python because it handles long-running processes and I/O well, and it has no dependency issues at the scale we use it.

The question we always ask is, “Does this tool solve a real problem we actually have, or does it create new problems while solving imaginary ones?”

But What About Laravel?

grok.com

Laravel is the best of the frameworks, I think. So I chatted with grok about the choices and showed it this page and the frugal code page because I wanted to make sure our principles still apply there in a specific site case.

Direct mapping to your own design principles

Your two pages make the case very clearly:

  • Frugal code / token economics: Laravel + Blade (or Vue/Inertia) routinely generates 350+ lines and thousands of tokens for a simple CRUD page. Your vanilla approach stays in the ~80-line / 500–800 token range. That difference compounds on every feature, every AI-assisted edit, and every debug loop. Laravel does not escape the context window and boilerplate tax you already quantified.
  • Technology choices: Page weight under ~200 KB gzipped, progressive enhancement, zero or near-zero dependency tree, static or near-static delivery where possible, long-term durability, and minimal attack surface. Laravel pulls in a large framework core, service container, Eloquent, routing layer, middleware stack, etc. Even a “minimal” Laravel app is heavier, more dependent, and harder to keep working unchanged in five years than plain PHP + vanilla JS.

You already noted the exception for a proper database on the auth server when it is genuinely required. That exception still holds. Needing a database for more than login does not force you into Laravel.

Practical comparison for codebnb.org

ConcernHandcoded / your stackLaravel
Page weight & mobile data costEasy to keep tinyHarder; the framework JS/CSS + assets add up.
Old / low-end devicesProgressive enhancement works by design.JS-heavy patterns fight it.
Dependency & supply-chain riskNear zeroLarge transitive surface
Hosting flexibilityCheap shared PHP hostsNeeds more capable hosting or containers
AI-assisted development costLow token volumeHigher context + more iteration
Database needsUse PDO / prepared statements (or a tiny wrapper) directly.Eloquent is convenient but not required.
Auth + extra dataYou already solved auth; extend the same pattern.Full framework auth is polished but overkill.
Long-term maintenanceFiles still work years later.Framework upgrades and deprecations keep coming.
Team familiarityCoders know Laravel.You and the principles already favor lean code.

Laravel shines when you have a large team, complex domain logic, lots of concurrent developers, or need the full ecosystem (queues, notifications, first-party packages, etc.). For a new site that is still being shaped and that you want to keep aligned with your principles, it is the heavier tool solving problems you do not yet have.

Recommended path

  1. Keep the public-facing site as lean as possible (static or near-static generation + progressive enhancement).
  2. Use a real database only where the state actually requires it (users, any domain data beyond login). Talk to it with thin, explicit PHP (or whatever you already use)—prepared statements, simple queries, no ORM if you can avoid it.
  3. If you are more productive in Laravel for the admin/backend pieces, consider isolating that part (or even a separate small service) rather than making the whole public site a Laravel app.
  4. Measure the actual page weight and token cost of the first few features either way. The numbers almost always favor the approach you already documented.

You do not need to convince anyone that Laravel is bad. You only need to show that, for this project and these constraints (users who pay for data, long-term simplicity, AI cost, and durability), the extra layers are not buying you enough to justify the cost. Your two design-principles pages already contain the strongest arguments; just apply them consistently to codebnb.org.