Amplication

Amplication is an open-source developer platform that automates the generation of backend microservices by encoding your organization’s architecture standards, security policies, and coding conventions into reusable Blueprint templates. Instead of every team re-implementing the same boilerplate from scratch, Amplication generates fully functional, customizable services — complete with REST and GraphQL APIs, typed data models, authentication, and database migrations — in minutes.

At its core, Amplication uses a plugin-driven code generation pipeline called the Data Service Generator (DSG). Teams can extend this pipeline with custom plugins that hook into generation lifecycle events to inject CI/CD manifests, add proprietary authentication schemes, include testing configuration, or apply internal naming conventions — all without forking the core generator.

Unlike scaffolding tools that produce throw-away starting points, Amplication maintains a live connection between your service definitions and your generated code. Changes to data models or API configurations automatically trigger new pull requests to your own git repository, keeping generated services up to date as organizational standards evolve.

Amplication supports multiple output targets including Node.js (NestJS/Prisma) and .NET (C#/ASP.NET), serving teams that need backend consistency across mixed technology stacks. A hosted SaaS version is available at app.amplication.com, while the platform can also be run entirely self-hosted for teams requiring full data sovereignty.

What You Get

• Blueprint Templates - Define organization-wide Golden Path service templates that encode your architecture decisions, security requirements, and coding standards so every generated service starts from the same compliant baseline.
• Plugin System - Extend the code generation pipeline with custom plugins that hook into lifecycle events to add CI/CD configurations, proprietary auth schemes, test frameworks, or internal tooling integrations without modifying core generator code.
• REST and GraphQL API Generation - Automatically generate typed REST and GraphQL APIs with full OpenAPI documentation, CRUD operations, input validation, and authentication middleware derived directly from your entity definitions.
• Data Model Designer - Visually define entities, fields, relationships, and permissions that auto-generate Prisma schemas, TypeScript DTOs, and PostgreSQL migrations.
• Automated Git PR Workflow - Every change to a service definition generates a pull request to your team’s own GitHub, GitLab, or Bitbucket repository — keeping your codebase current and letting your existing review process control what merges.
• Multi-target Code Generation - Generate Node.js services using NestJS, Prisma, and Apollo GraphQL, or produce equivalent C#/ASP.NET services for .NET shops — from the same entity definitions.
• Service Catalog - Browse and manage all generated services across teams through a central catalog with relationship visibility and health status.
• Own-Your-Code Architecture - All generated code is standard, vendor-lock-free TypeScript or C# that your team can modify, extend, and maintain independently of the Amplication platform.

Common Use Cases

• Platform engineering teams standardizing backend development - A platform team creates Blueprint templates that embed their company’s observability, authentication, and API design standards, so every new microservice created by any product team automatically starts compliant.
• Accelerating new service creation in large organizations - Engineering managers use Amplication to reduce time-to-first-commit for new backend services from weeks to hours by eliminating manual boilerplate setup across database migrations, API layers, and deployment configuration.
• Maintaining consistency across growing microservice fleets - As coding standards evolve, platform engineers update Blueprint templates and Amplication regenerates PRs across all dependent services, keeping hundreds of services aligned without manual coordination.
• Mixed-stack enterprises needing unified tooling - Organizations running both Node.js and .NET services use Amplication’s dual code generators to apply the same entity modeling workflow and organizational standards across both technology stacks.
• Compliance-driven backend development - Fintech and healthcare teams encode audit logging, RBAC, data encryption requirements, and SOC 2 controls into templates so every new service ships with compliance controls pre-installed.
• Legacy modernization through incremental service replacement - Engineering teams generate new NestJS or .NET microservices with identical API interfaces to legacy services, enabling incremental traffic migration without disrupting consumers.

Under The Hood

Architecture Amplication is structured as an event-driven distributed system within a TypeScript monorepo managed by Nx. The NestJS server handles all user-facing operations through a GraphQL API and communicates asynchronously with the Data Service Generator, Build Manager, and Git Sync components via Kafka. This event-driven topology means that triggering a code build results in a message being emitted to Kafka, allowing the generator to process jobs independently without blocking the main server — and enabling each component to scale separately under load. The Blueprint system sits at the top of this hierarchy: Blueprints define organizational Golden Paths that cascade their standards into all services associated with them, enforcing consistency through generated code rather than documentation. The Plugin API component acts as a catalog service for the code generation plugin ecosystem, serving available plugins to clients and managing their versioning.

Tech Stack The platform is built on Node.js 22 with TypeScript strict mode across all packages. NestJS provides the server framework with Apollo Server handling GraphQL, and Prisma ORM manages all database interactions against PostgreSQL. Kafka via KafkaJS drives asynchronous inter-service communication. The React client uses Apollo Client with generated TypeScript types, Monaco Editor for in-platform code viewing, and MUI for component styling. The Data Service Generator uses a ModuleMap abstraction — a virtual file system — that plugins transform before being written to disk or pushed as a pull request. A separate generator-blueprints package handles the .NET/C# code generation path. Redis provides caching. Nx manages distributed build caching across the monorepo.

Code Quality The codebase demonstrates strong engineering discipline with extensive test coverage across approximately 200 spec files using Jest — covering NestJS services, GraphQL resolvers, and domain logic with comprehensive dependency mocking via @nestjs/testing. TypeScript strict mode is enforced throughout with explicit interfaces, typed DTOs, and code-generated GraphQL types ensuring end-to-end type safety from API schema to client code. Error handling follows a structured hierarchy using custom AmplicationError subclasses alongside standard NestJS exceptions. ESLint and Prettier enforce consistent style. GitHub Actions CI gates all pull requests on lint, type checks, and tests. The entity service in particular demonstrates careful domain modeling with optimistic locking, soft deletes, and schema versioning.

What Makes It Unique Amplication’s most distinctive technical contribution is its compile-time plugin injection architecture. Unlike low-code tools that lock you into a proprietary runtime, Amplication plugins operate at code-generation time — transforming the virtual ModuleMap before code is emitted — so the resulting codebase contains no runtime dependency on Amplication whatsoever. The Blueprint system extends this by letting platform teams define hierarchical organizational templates with custom typed properties that propagate through all affiliated services. The combination of git-native output (PRs to your own repo), compile-time extensibility, and multi-target generation (Node.js and .NET from the same entity model) creates a genuinely different value proposition from both low-code platforms and scaffolding CLIs.

Self-Hosting

Amplication uses a split licensing model: all code under the packages/ directory is released under the Apache License 2.0, which is permissive — you can use it commercially, modify it, and redistribute it without requiring you to open-source your own code. The ee/ directory, which contains the git-sync-manager and related enterprise features, is licensed under the Amplication Enterprise Edition License, a proprietary license that restricts modification and redistribution. In practice, this means the core code generation engine and API server are fully open-source, while some integrations that connect to external git providers fall under a commercial license.

Running Amplication self-hosted is a substantial operational commitment. The platform requires PostgreSQL, Redis, Kafka (with Zookeeper or a managed equivalent), and a container orchestration environment to run all services — the Docker Compose configuration brings up the server, client, data service generator, build manager, git sync service, plugin API, and notification service as separate containers. Teams are responsible for securing the PostgreSQL instance, managing Kafka broker health, handling service restarts, and applying upgrades manually. The architecture diagrams in the repository illustrate the full system topology, which is genuinely complex — expect this to require dedicated DevOps attention rather than a single-command self-install.

The hosted SaaS tier at app.amplication.com abstracts away all of this infrastructure management and includes managed upgrades, HA, and direct support from the Amplication team. The cloud version also provides access to AI-powered features (the GPT Gateway component) and tighter integrations with external tools that may require the EE license. Teams choosing self-hosted gain full data sovereignty and the ability to air-gap the deployment, but give up SLA guarantees, managed scaling, and the operational simplicity of the cloud offering. For most organizations just beginning with Amplication, starting with the hosted tier to validate the workflow before investing in a self-hosted deployment is the pragmatic path.