Node.js with Fastify and Prisma, and the same principle on the frontend

Start from an architecture that is ready for production

Describe the system and get the whole application generated with Clean Architecture: domain, application and infrastructure kept apart, use cases, a DTO distinct from the entity, repository and tests. This is not a README promising a pattern: it is the code that comes out, with your domain inside.

Generate with Clean Architecture → See the layers

7 days free to generate and test. Pay only to take the code. A standard project, with no platform runtime.

1,600+ Real application models

100% Code that compiles, no hallucination

3 Layers of tests generated

create-patient-usecase.ts

// constructor injection, no magic field

export class CreatePatientUseCase

constructor(private readonly repo:

PatientWriteRepository) {}

// the DTO is the contract, the entity stays inside

async execute(input: CreatePatientInput)

: Promise<PatientOutput> {

const entity = await this.repo.create(...)

return toPatientOutput(entity)

}

✓ same pattern in every generated module

How it works

You describe the system. The architecture comes with it.

The order matters: first the AI understands the business and picks the model, then the generator writes the code. The architecture is why the result holds up, not a form you fill in at the door.

Describe the system

The AI runs a requirements discovery: what gets tracked, who uses it, what each profile is allowed to do.

The model is chosen

Among more than 1,600 models of real business applications, the closest to your case, adapted to your domain.

The generator writes the code

From deterministic templates. Every module is born with the same layer separation as the previous one.

Compile, test and check

Compilation, lint, three layers of tests and a check against the API contract, before you download it.

Data model of a ClickMVP project, with tables, fields and types

This model is where the entity, DTOs, repository, service, controller, migration, permissions and screens of every registry come from.

The goal of ClickMVP is not merely to generate code. It is to generate organised, sustainable software, prepared to keep evolving after the team takes over.

The layers

Separation that survives the second month

This is not folder tidiness. It is dependencies pointing inward, with the domain unaware that HTTP or a database exist.

Domain

Your business entities and invariants. No web framework annotation, no knowledge of the transport, no dependency on the caller.

Application

The use cases: the service that orchestrates, validates, applies permission and returns a DTO. This is where your specific rule goes, with a test beside it.

Infrastructure

Persistence, email, storage, payment gateway and the REST controller. Replaceable, because nothing in the domain depends on a detail from here.

Rules the generator will not let you break

The boring part is the one that costs the most later

Every team starts with the right architecture. What erodes it is Tuesday's shortcut. Since the code here is generated from templates, the shortcut has no way in: every new module is born identical to the previous one.

✓ The route answers through the DTO, never through the persistence row
✓ Input validated at the boundary, with a predictable, translated error
✓ Permission checked on the server, not merely by hiding the button
✓ Token in an HttpOnly cookie, nothing kept in the browser
✓ Reading someone else's row answers 404, not a 403 that confirms it exists
✓ Schema versioned in migrations from the first commit
✓ A single API contract, checked on every generation

what runs before you download

✓ backend compilation

✓ lint and style check

✓ unit tests of the services

✓ route tests with the app running

✓ end to end tests in the browser

✓ check against the API contract

✓ database schema matching the model

# deterministic template code:

# not one line written by guesswork

548 TypeScript files, one folder per domain module

182 REST endpoints checked against the canonical contract

60 unit, route and end to end test files, with Vitest

43 tables in the migration versioned from the first commit

Measured on a real project of 43 registries, generated in Node.js and React: 41,000 lines in the backend, 80,000 in total, with a DTO separate from the entity in every module.

On the frontend too

SOLID does not stop at the backend border

The React frontend follows the same split of responsibility, translated into the framework's idiom.

Pure presentational component

The table and the form do not know who the user is or what they may do. They take data and actions, and nothing else. Testing is trivial.

The page orchestrates

State, loading and permission live in the page. The action a person may not take never reaches the component, so it does not exist on screen.

HTTP isolated in a service

No screen calls the API directly. Access lives in a typed service, aligned with the backend's OpenAPI contract.

Frequently asked questions

What a technical team asks first

Where do my business rules go?+

In the module's service, which is where the application layer already lives. The generator hands you the CRUD, the model validations and the whole base of access control, audit and billing already working. Your specific rule goes into a place that already exists, with a test next to it, instead of you building the structure before writing the first line of what actually matters.

How is the architecture split between backend and frontend?+

The principle is the same on both sides, never diluted. On the backend: domain, application and infrastructure kept apart, a DTO distinct from the persistence entity, and constructor injection. On the frontend: a pure presentational component, the page orchestrating state and permission, and HTTP access isolated in a service.

How do you guarantee the generated code compiles?+

The code comes from deterministic templates, not from a language model writing line by line, so there is no hallucination on the code path. Every generation goes through compilation, lint, unit, route and end to end tests, and a check of the result against the generator's canonical API contract.

Is this a boilerplate or a Node.js template?+

It is the next step. A template gives you the empty structure and you code every CRUD, every screen and every permission of your domain. Here the starting point is more than 1,600 real business application models: the AI picks the closest one to your case, adapts it to your business, and your domain comes out generated with tables, screens, roles, audit and billing working. The code is a standard project that opens in any IDE.