DEV Community: DevEngine Labs

The Scaffolding Engine is Live — 128 Stacks, One Configurator, Zero Opinions

DevEngine Labs — Thu, 18 Jun 2026 21:56:02 +0000

This is the follow-up to my earlier post about building an infinite full-stack assembly line. The engine is no longer "coming soon." It shipped.

Last week I wrote about a problem every developer knows intimately: you buy a boilerplate, spend the first three days tearing out the choices you didn't make, spend three more days figuring out why the pieces you kept are broken, and by the time you're writing actual business logic you've lost a week of momentum.

I said I was building something different. Here's what actually shipped.

What DevEngine Labs Does

You pick one option from four layers:

Frontend: Next.js, React SPA, Nuxt, or SvelteKit
Backend: Express, FastAPI, Fastify, or NestJS
Auth: Clerk or Auth.js
Billing + Database: Stripe + Supabase, Stripe + Firebase, LemonSqueezy + Supabase, or LemonSqueezy + Firebase

The engine pulls your four selected modules, compiles them into a single zip, generates a README written specifically for your combination, and delivers it. The auth is already wired to the backend. The payment webhooks are already connected. The database client is already initialized.

You unzip, drop in your API keys, run install, and you're writing features.

That's 4 × 4 × 2 × 4 = 128 distinct, pre-tested combinations — all available right now.

Why This Architecture Works

The key insight is treating each layer as a strictly decoupled module with enforced boundary contracts. The FastAPI backend module doesn't know or care whether it's being paired with Next.js or SvelteKit. The Clerk auth module doesn't know whether it's sitting on top of Supabase or Firebase. Each module exposes a clean interface and the compiler handles the wiring.

This is why adding a single new module multiplies the library rather than adding to it. When Prisma and Drizzle drop in as database/ORM modules in the next phase, the combination count doesn't go from 128 to 130 — it goes to 512+. The architecture scales geometrically.

The Stack Nobody Else Supports

Every major boilerplate on the market is a Next.js product. Some of them are excellent Next.js products. But if your MVP calls for a Python backend — and if you're building anything AI-adjacent in 2026, it probably does — you're on your own.

FastAPI + any frontend is completely unserved by the current boilerplate market. Same with Nuxt. Same with SvelteKit. Those communities are starved for production-ready starting points.

DevEngine is the only place I'm aware of where you can get a pre-wired Nuxt + FastAPI + Clerk + Stripe stack as a downloadable zip. If that combination describes your next project, it exists. Right now. Ready to run.

What's Coming

The next phase is the database expansion loop I wrote about in my first post. Prisma and Drizzle are already in testing as injectable ORM modules. When they land, the library hits 512+ combinations.

After that: multi-backend configurations. Some architectures genuinely need a Node.js API layer handling real-time operations alongside a Python service handling ML inference. That configuration will be selectable as a single purchase.

The economics of automated module compilation make it possible to keep adding layers without the maintenance overhead that would make this unworkable as a manually-maintained template library.

Try It

The configurator is live at dev-engine-labs.vercel.app.

Pick your stack. If your combination exists — and there's a 100% chance it does (or will very soon) — you'll have it in your inbox before you finish reading this sentence.

One-time purchase. No subscription. No opinionated leftovers.

I'm Building an Infinite Full-Stack Assembly Line (And Why the Boilerplate Market is Dead)

DevEngine Labs — Mon, 15 Jun 2026 04:07:39 +0000

Every developer knows the absolute worst part of starting a new software project.It isn't writing the features, designing the UI, or talking to users. It’s the mind-numbing, repetitive grunt work of wiring up the baseline infrastructure before you can write a single line of business logic.You open a blank IDE and immediately spend 20 hours trying to make Next.js talk to FastAPI, debugging environment variables across different programming language runtimes, routing auth webhooks through Clerk, and testing payment handshakes.By the time the app finally compiles, you've burned a week of billable time.

The Problem with "Opinionated" Boilerplates

To fix this, we buy boilerplates. But the current market leaders are broken. They sell static, rigid templates tightly coupled to one single tech stack (usually Next.js + MongoDB + Stripe).If a client or an MVP requires you to swap to a high-performance Python backend or a lightweight SvelteKit frontend, that $250 boilerplate shatters. You have to tear the codebase apart and start from scratch.A boilerplate shouldn't be a pre-furnished house that forces you to live with the creator's messy code opinions. It should be a pristine, adaptive launching pad.

What I am Building: The DevEngine Matrix

I am currently engineering DevEngine Labs—the world’s first combinatorial software scaffolding engine.Instead of writing static templates by hand, I am building a proprietary, black-box orchestration compiler. It treats software frameworks like modular Lego bricks. By enforcing strict, decoupled boundaries between layers, the engine can take isolated modules and compile them into every mathematically possible full-stack combination on demand. My goal? Total cross-language architectural freedom.I am currently expanding the core module matrix across:

4 Frontend Frameworks: Next.js, SvelteKit, Nuxt (Vue), and React SPA
4 API Backend Runtimes: Express, FastAPI (Python), Fastify, and NestJS
2 Authentication Systems: Clerk and NextAuth
2 Global Payment Gateways: Stripe and Lemon Squeezy

File Tree example:

Folder PATH listing
C:.
│ package.json
│ README.md
│

├───adapter-stripe
│ │ package.json
│ │ srcindex.ts
│ │

│ └───src
│ index.ts
│

├───backend-fastapi
│ main.py
│ package.json
│ requirements.txt
│

├───frontend-nextjs
│ │ next-env.d.ts
│ │ package-lock.json
│ │ package.json
│ │ srcappapiedge-handlerroute.ts
│ │ tsconfig.json
│ │

│ └───src
│ └───app
│ └───api
│ └───edge-handler
│ route.ts
│

└───shield-clerk
│ package.json
│ srcindex.ts
│

└───src
index.ts

When these modules run through the compiler, it automatically outputs 128 completely distinct, production-ready full-stack starting grids.

Phase 2: The Database Expansion Loop

Because this is an automated matrix, adding a module doesn't add one feature—it multiplies across the entire system. Next up, I am hand-verifying modular database and ORM integration layers for Prisma, Drizzle, native PostgreSQL, and MongoDB. The moment those modules drop into the compiler, the library instantly quadruples from 128 combinations to 512+ pristine full-stack permutations. No tech lock-in. No bloated boilerplate code. You select your exact tech setup, the engine compiles it securely in milliseconds, and hands you a tailored, dependency-isolated ZIP.You unzip, drop your API keys, and couple the code exactly how you want once you start building.

Building in Public

Maintaining 512 variations manually is an engineering nightmare. Doing it through an automated, serverless compilation pipeline changes the economics of software manufacturing entirely. It allows me to completely undercut the over-priced, rigid template market and offer custom, pristine codebases at lightning speed.The architecture engine is built. The security perimeters are locked. The database injection scripts are running.I am building the ultimate developer tool platform to automate the infrastructure grind forever.If you want to stop fighting opinionated templates and track the launch of the infinite scaffolding factory, follow along. The engine goes live soon.