# Amplication: a Golden Paths service catalog that generates NestJS and Prisma services

> Amplication turns data models and plugins into generated backend services, and the repository ships both the hosted product and the self-hosted monorepo. The self-hosted path is a development setup, not a one-line install, and the docs are the place to start.

**amplication/amplication** — Amplication brings order to the chaos of large-scale software development by creating Golden Paths for developers - streamlined workflows that drive consistency, enable high-quality code practices, simplify onboarding, and accelerate standardized delivery across teams.

- Repository: https://github.com/amplication/amplication
- Website: https://amplication.com
- Stars: 16,017 · Forks: 1,541
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/amplication-amplication

## The problem Amplication targets: inconsistent backends across many teams

The README frames the project as bringing order to large-scale software development by creating Golden Paths: workflows that keep generated services consistent and simplify onboarding. The intended user is a platform engineering team that wants every new service to start with the same APIs, data models, DTOs and conventions, rather than whatever the last developer chose. The repository topics list api, code-generation, graphql, nestjs, prisma, nodejs, typescript, dotnet, csharp and low-code, so the generated output is not limited to one stack. The README also states that Amplication automatically handles package updates, patches and versioning, which is the part that matters after the first generation: a service that drifts from the template is the usual failure of scaffolding tools. If your team writes one service a year, the setup cost described below will not pay for itself.

## How generation works: models, plugins and a data-service-generator

The mechanism visible in the repository is a chain. A service definition holds data models and settings; plugins extend what the generator emits; the data-service-generator turns that definition into code. The package.json exposes this as its own runnable application: serve:dsg starts amplication-build-manager and local-data-service-generator-controller together, and there is a separate debug:dsg script that runs nx generate-local-code data-service-generator. A git-sync-manager (serve:git) and a plugin-api (serve:plugins) exist as separate services, which tells you the architecture is several cooperating processes rather than one binary. The generated stack leans on NestJS and Prisma per the repository topics, with GraphQL among the exposed APIs. The README describes live templates as the place where an organisation embeds its own standards, so the customisation point is the template and plugin layer, not a post-generation patch script.

## Installing Amplication locally with the Nx monorepo

The README's Usage section points first at the hosted product, app.amplication.com, where you log in and are guided through creating your first service. The Development section covers running it locally, and it lists Node.js, Docker and Git as prerequisites. It also states that TypeScript must be installed globally before you start, and that you should check the engines entries for node and npm in package.json for supported versions. The commands below are copied from the README and package.json; the first clones the repository and installs dependencies, the second runs the setup script that installs dependencies, builds packages and prepares the workspace.

```bash
git clone https://github.com/amplication/amplication.git && cd amplication && npm install
npm run setup:dev
```

The infrastructure comes up through Docker Compose, either in the foreground or in the background with -d. Then migrations are applied before any application is served.

```bash
npm run docker:dev
npm run docker:dev -- -d
npm run db:migrate:deploy
```

Finally you start the pieces you need. The README notes that the client requires both the client and the server to be running, and that each application has its own serve script.

```bash
npm run serve:server
npm run serve:client
```

There is also a GitHub Codespaces route: the README says to open the Code menu, choose Codespaces instead of Local, and click the plus sign or Create codespace on master. What you should see after these steps is a running server and client backed by the Docker Compose infrastructure, with the other services available through serve:dsg, serve:git, serve:storage, serve:plugins and serve:notification when you need them.

## Where Amplication is the wrong tool

The self-hosted story is a development setup. The README puts local running under Development and says it is for code generation purposes or contributions, and the setup script is named setup:dev. There is no documented production deployment path in the README, no install command for a packaged release, and no rollback procedure: the README does not document rollback. The repository also contains an ee/ directory alongside the Apache 2.0 badge in the README, and the GitHub licence field reads NOASSERTION, so the split between what the badge covers and what ee/ covers is something to read in LICENSE before you plan around it. If your requirement is a single container you can hand to an operations team, this repository does not present itself that way. It is also a poor fit when the generated service would be smaller than the template machinery around it.

## Amplication compared with plain NestJS CLI scaffolding

The NestJS CLI generates a project skeleton once and then gets out of the way; you own every subsequent change, and nothing pushes updates back into the repository. Amplication keeps the definition as the source of truth and regenerates, which is why the README can claim automatic package updates, patches and versioning. The difference in practice is where your customisation lives. With the CLI it lives in the code you edited after scaffolding. With Amplication it is supposed to live in live templates and plugins, so the next generated service inherits it. That is a real gain for a platform team maintaining dozens of services, and a real cost for a team of two who will never write the second service, because they now maintain a definition and a template layer on top of the code they actually ship.

## Maintenance cost, releases and licence questions

The last push to the default branch master was on 2026-06-30. Recent releases are v3.15.0 on 2026-04-02, v3.14.0 on 2025-04-25 and v3.13.1979 on 2025-03-12, so the release cadence in the release list is uneven rather than monthly. Upgrading means tracking the monorepo: the root package.json pins engines for node and npm, and the setup script builds packages, so a version bump can require re-running npm run setup:dev and npm run db:migrate:deploy. The README advertises automatic dependency updates for generated services, which shifts some of that work to the generator, but the generator itself is the thing you must keep current. On licensing, the README shows an Apache 2.0 badge while the repository reports NOASSERTION and ships an ee/ directory; treat that as a question for whoever signs off on licences rather than something to assume.

## Conclusion

Adopt Amplication if your platform team wants generated services that carry your own conventions through live templates, and you are willing to run the Nx monorepo locally or use the hosted product. Do not adopt it if you need a one-command self-hosted install or a documented rollback story, because the README does not provide either. Before committing, check the engines entries for Node.js and npm in package.json, confirm the licence terms for the ee/ directory against the Apache 2.0 badge, and read the docs at docs.amplication.com for the current plugin and template behaviour.

## FAQ

### How do I install Amplication locally?

The README's Development section lists Node.js, Docker and Git as prerequisites and requires TypeScript installed globally. You clone the repository, run npm install, then npm run setup:dev, bring up infrastructure with npm run docker:dev, apply migrations with npm run db:migrate:deploy, and start applications such as npm run serve:server and npm run serve:client. Check the engines entries for node and npm in package.json for supported versions.

### Is Amplication free to use, and what licence applies?

The README displays an Apache 2.0 badge, but the repository's licence field reads NOASSERTION and an ee/ directory is present in the top-level entries. The README does not state which parts fall under which terms, so read LICENSE in the repository before relying on the badge.

### Can I use Amplication without running the monorepo?

Yes. The README's Usage section says the hosted version can be used and points to app.amplication.com, where login is followed by a guided flow for creating your first service. The local setup is described as being for code generation purposes or contributions.

### What does Amplication generate for a service?

The README says Amplication generates microservices with the APIs, data models and DTOs needed for a business domain, leaving engineers to write business logic. The repository topics include nestjs, prisma, graphql, typescript, dotnet and csharp, and the data-service-generator is runnable on its own through the serve:dsg script.

## Sources

- [amplication/amplication on GitHub](https://github.com/amplication/amplication)
- [Issues](https://github.com/amplication/amplication/issues)
- [Project website](https://amplication.com)
- [README](https://github.com/amplication/amplication/blob/master/README.md)
- [Releases](https://github.com/amplication/amplication/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/amplication-amplication