Amplication
Code generation platform for production-ready backends
Amplication is an open-source backend development platform that generates production-ready Node.js applications with APIs, authentication and database access. It can be self-hosted to build and manage services.
Key features
- Generates Node.js backends
- REST and GraphQL APIs
- Built-in auth
- Plugin system
Pros & cons
Strengths
- Generates production boilerplate
- Auth included out-of-box
- Git sync workflow
Trade-offs
- Node.js stack only
- Some features paid
Amplication replaces
Last reviewed Aug 26, 2026 · 784 words
Amplication is not a backend you host. It is a factory that emits one. You describe entities, fields, relations and roles in its UI, and it commits a complete Node.js project with REST and GraphQL endpoints, JWT authentication, a Prisma data layer and a Dockerfile to your Git repository. The self-hosted server is the factory, not the product, which changes the maths for a homelab: you install a 2 GB platform in order to produce apps that each need far less than that.
What actually comes out
The generated project is NestJS with Prisma against PostgreSQL, MySQL or MongoDB, with a CRUD controller and resolver per entity, role-based access rules per field, OpenAPI documentation, and a matching React admin UI if you want one. The code is readable, conventionally structured and yours: Apache-2.0 platform, no runtime dependency on Amplication once generated. That last point is the real selling feature. A low-code tool that produces a normal repository has an exit, and most of the Retool-style alternatives do not.
Where the output falls short is anything beyond CRUD. Business logic, background jobs, external API calls and non-trivial queries are yours to write, and the generator's job is to have laid out the scaffolding so that writing them is boring.
Git sync is the workflow, and the merge is the trap
Amplication pushes generated code to a branch on GitHub, GitLab, Bitbucket or Azure DevOps and opens a pull request into your main branch. You write custom code in the same repository; regeneration produces a new PR rather than overwriting files, and the platform keeps generated and custom regions separable so that most regenerations merge cleanly. Most, not all. The moment you edit a generated file heavily, every entity change becomes a merge review. The discipline that makes this work is to keep custom logic in new files and services rather than editing the scaffolding, and to decide up front whether you will keep regenerating or treat generation as a one-time bootstrap. Both are legitimate; mixing them is where teams lose afternoons.
The self-hosted server is heavier than what it makes
Self-hosting runs the Amplication server, the client, PostgreSQL and a message broker for the build pipeline, plus the code-generation worker that produces the projects. The listed minimum is 2 GB and the Compose stack in the repository is meant for evaluation rather than production. The hosted version is free for the core workflow, with some git providers, plugins and team features on paid tiers, which the catalogue summarises as "some features paid". For an individual, running the hosted service and self-hosting the generated app is the path of least regret: your data is the repository, which you already own. Self-hosting the platform makes sense for a company that cannot send schema definitions to a third party, or for a team producing many services from one plugin set.
Node.js only, and that is the decision
The mature target is NestJS on Node.js, and if your stack is Go, Python or .NET, a generator that emits TypeScript is not a shortcut, it is a second stack. The plugin system lets you swap authentication providers, add Kafka or a cache, and adjust the database, but it customises the Node.js output rather than replacing it.
Who should pick something else
| You want | Pick |
|---|---|
| A backend in one binary with auth and admin UI, no code generation | PocketBase |
| Postgres plus auth, storage and realtime as a hosted-style platform | Supabase |
| An admin panel and API over an existing database | Directus |
| A NestJS codebase you will own and extend heavily | Amplication |
PocketBase in particular covers the "I need users, records and a REST API by tonight" case with 20 MB of RAM and no generated code to maintain. Amplication wins only when the output being a real, conventional codebase is the point, because a team of developers is about to live in it.
What I'd do
Use the hosted platform to generate the first version of the service, connect it to a repository on your own Forgejo or GitHub, and self-host the generated NestJS app alongside its Postgres on any 1 GB box. Only stand up the Amplication server itself if a policy forbids the hosted one, and give it 4 GB rather than the 2 GB minimum if you do. Treat generation as a bootstrap, write new logic in new files, and keep regenerating only while the data model is still moving. For a personal project that is not a NestJS codebase in waiting, install PocketBase and be done in an hour.
Compare Amplication
6 head-to-head comparisons.
Similar developer tools & git apps
Excalidraw
Developer Tools & GitVirtual hand-drawn style whiteboard
Replaces Miro
lazygit
Developer Tools & GitSimple terminal UI for Git commands
Replaces GitKraken, Sourcetree
Hoppscotch
Developer Tools & GitOpen-source API development ecosystem
Replaces Postman, Insomnia
json-server
Developer Tools & GitFull fake REST API from a JSON file in seconds
Replaces Mockoon, Postman Mock
Strapi
Developer Tools & GitLeading open-source headless CMS
Replaces Contentful
NocoDB
Developer Tools & GitOpen-source Airtable alternative
Replaces Airtable