# prisma/prisma-examples: what the ready-to-run projects actually contain

> A walk through the repository layout, the ORM example categories, and what you can and cannot infer from a set of sample projects maintained by the Prisma team.

**prisma/prisma-examples** —  🚀 Ready-to-run Prisma example projects

- Repository: https://github.com/prisma/prisma-examples
- Website: https://www.prisma.io/docs/
- Stars: 6,648 · Forks: 1,470
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/prisma-prisma-examples

## What prisma/prisma-examples is for, and who should open it

The repository describes itself as containing "a number of ready-to-run example projects demonstrating various use cases of Prisma." That sentence is the whole contract. It is not a starter template you fork and grow, and it is not a library. It is a catalogue. Each entry under the top level is a self-contained project with its own README, and the top-level README exists mainly to route you to the right one.

The audience is narrow but real. If you have decided to use Prisma and you now need to see how it fits a specific framework, the repository answers that question faster than the documentation does, because the code is complete rather than excerpted. The fullstack table lists Next.js 15 with the App Router, Next.js with GraphQL, Next.js with tRPC, Nuxt, SvelteKit, Remix, and a Nuxt example built on the Prisma Nuxt module. The backend tables cover GraphQL servers in several styles: email-password authentication, SDL-first with GraphQL Yoga, realtime subscriptions, TypeGraphQL, and Fastify with Mercurius.

What it is not for: anyone looking for a single canonical way to structure a Prisma application. The examples deliberately diverge from each other, because each one demonstrates a different integration. Reading three of them side by side will show you three different project shapes, and none of them claims to be the recommended layout.

## How the repository is organised under the top level

The top-level entries are directories grouped by concern rather than by framework: accelerate/, compute/, databases/, deployment-platforms/, generator-prisma-client/, orm/, plus tests/, package.json, tsconfig.json and vitest.config.ts. The orm/ directory is the one the README spends its tables on, and it is where the framework examples live.

Inside orm/, the split is fullstack versus backend only. Fullstack examples pair a UI framework with a data layer, so the Next.js entry uses the App Router, the SvelteKit entry uses SvelteKit's actions and load functions, and the Nuxt entry exposes a REST API. Backend-only examples drop the UI and focus on the API surface, which is why so many of them are GraphQL servers built on different schema libraries: Nexus, TypeGraphQL, and graphql-tools each get their own directory.

The separate directories for accelerate/, compute/ and deployment-platforms/ signal that the repository tracks more than the ORM. Those are Prisma's hosted and deployment surfaces, and examples there will look structurally different from the orm/ projects. The databases/ directory is the place to look if your question is about a specific engine rather than a specific framework.

One structural detail worth noticing: the root package.json is marked "private": true and declares a single script, test, which runs vitest. The root is a test harness for the examples, not an application. Dependencies for any individual example live in that example's own package.json, which the top-level file does not mirror.

## Installing and running one example: the nextjs app

The README does not give install steps at the top level. It says to pick an example and follow the instructions in the corresponding README, so the commands below follow that path rather than inventing a root-level workflow.

Start by cloning the repository and moving into the example directory. The default branch is latest, and the README's own links point at tree/latest/orm/nextjs, so that is the path to use.

```bash
git clone https://github.com/prisma/prisma-examples.git
cd prisma-examples/orm/nextjs
```

From here you are in a standalone Next.js project. Its own README is the authority on the remaining steps, and the root README's description of this entry is specific: a Next.js 15 app using the App Router with Prisma Postgres. Because the data layer is Prisma Postgres rather than a local database file, expect the example's README to cover provisioning or connecting to that database before the app will start.

If you want to check the repository's own test setup instead, the root package.json defines exactly one script and it is not a dev server:

```bash
npm install
npm test
```

That runs vitest against the tests/ directory. It validates the examples as a collection. It does not start any individual app, and running it will not tell you whether your chosen example boots.

## The GraphQL examples are where the repository earns its keep

Most of the backend-only table is GraphQL, and the duplication is the point. graphql-auth shows email-password authentication with permissions. graphql-sdl-first uses GraphQL Yoga and takes the schema-definition-language-first route. graphql-subscriptions adds realtime subscriptions on apollo-server with a Nexus schema. graphql-typegraphql and graphql-typegraphql-crud both use @apollo/server with TypeGraphQL, one as a general server and one as a CRUD API. fastify-graphql uses Fastify with Mercurius and the SDL-first approach of graphql-tools, and fastify-graphql-sdl-first appears to be a variant of the same idea.

That spread is useful precisely because the differences are library choices, not application logic. If you are deciding between a code-first schema library and an SDL-first one, the repository lets you read two implementations of a comparable server and compare the shape of the resolver and schema code directly. That is a harder comparison to make from documentation alone.

The trade-off is that the examples age at different rates. Each one pins its own framework and schema library versions, and the README tables do not state versions for most entries. A GraphQL example built on apollo-server will not automatically track the same conventions as one built on @apollo/server, and the repository does not present them as equivalent. Treat each directory as a snapshot of how that combination was wired at the time it was last touched.

## Where this repository will mislead you

The biggest risk is treating an example as a reference architecture. These are demonstrations, and demonstrations optimise for showing a feature in as few files as possible. Error handling, input validation, migration strategy, connection pooling and deployment configuration are the parts that get compressed, and those are exactly the parts that decide whether a real service survives contact with production.

The second risk is version drift. The repository has no retrieved releases, so there is nothing to pin against and no changelog to read. The root devDependencies are pinned to exact versions (typescript 5.9.3, vitest 3.2.6, execa 9.6.1, @types/node 25.5.0), but that is the test harness, not the examples. Each example's dependencies are its own problem, and the top-level README does not list them.

The third is scope confusion. If your question is "how do I model a schema for a multi-tenant SaaS product," this repository has no answer. It answers "how do I connect Prisma to SvelteKit," and it answers that well. The databases/ and deployment-platforms/ directories widen the surface, but they do not turn the collection into a design guide.

Finally, the repository is a Prisma-maintained project with a contribution guide and an issue tracker, and the README explicitly invites you to open an issue if an example is missing. That is an invitation to request coverage, not a commitment that any particular gap will be filled.

## Alternatives, and why you might pick one instead

The most direct alternative is the official Prisma documentation at prisma.io/docs, which the repository's homepage points to. The difference in approach is that the docs teach concepts in isolation and keep code snippets current, while the examples ship whole runnable projects that can fall behind their frameworks. If you want to understand Prisma Client's query API, the docs are the better source. If you want to see a working Next.js App Router project wired to Prisma Postgres, the example is the better source, because the wiring is the part the docs tend to abstract away.

A second alternative is a framework's own scaffolding, such as create-next-app or the SvelteKit project creator. Those produce a project shaped by the framework's current defaults and give you a clean upgrade path. The trade-off is that you then add the database layer yourself, and you lose the pre-wired Prisma integration that is the only reason to open this repository in the first place.

A third option is a generic starter template from the wider ecosystem. Those often bundle authentication, styling and deployment configuration that prisma/prisma-examples deliberately omits. They also carry their own maintenance risk, and unlike this repository they are not backed by the vendor whose client they use. The honest comparison is: this repository is narrow, vendor-maintained, and current as of its last push on 2026-09-21; generic templates are broader and maintained by whoever wrote them.

## Maintenance, licensing and what to verify before you copy

The repository is not archived, and the last push was on 2026-09-21, so it is being touched. That tells you the collection is alive. It does not tell you that any individual example is current, because a push can update one directory, the CI configuration or the test harness without touching the rest. The README's test badge points at a workflow on the latest branch, which suggests the examples are exercised in CI, but the README does not state what that workflow covers.

The licence is Apache-2.0, which is a permissive licence that generally allows commercial use and modification. Whether you can copy code from an example into your own product is a question for your own legal review; the repository does not add notices or per-file terms that would change the reading, and this is not legal advice.

Upgrade cost is the part the README is thinnest on. There are no retrieved releases, so there is no changelog, no migration notes and no version history to consult. The practical consequence is that you should verify three things yourself before adopting a directory: the versions declared in that example's own package.json, whether its README still matches the code, and whether the framework conventions it uses are the ones your project targets. The root package.json will not help with any of those, since it only describes the test harness.

## Conclusion

Use prisma/prisma-examples if you want a working starting point for a Prisma stack you have not used before and you are willing to read the per-example README, because the top-level README only routes you to it. Do not use it as a production template: the repository is a demo collection, the root package.json is private with a single vitest script, and there is no retrieved release history to pin against. Before copying anything, open the specific example directory under orm/ and check its own package.json and README, since the top-level file does not describe dependencies for any individual app.

## FAQ

### How can I use prisma/prisma-examples?

Pick an example from the tables in the repository README and follow the instructions in that example's own README. The top-level README states that each project is ready to run and routes you to the corresponding directory, such as orm/nextjs or orm/graphql-auth.

### What exactly is prisma/prisma-examples?

It is a repository of ready-to-run example projects demonstrating various use cases of Prisma, grouped into directories such as orm/, databases/, compute/ and deployment-platforms/. The orm/ directory holds framework examples like Next.js, Nuxt, SvelteKit and Remix alongside backend-only GraphQL and Fastify servers.

### Why do people use prisma/prisma-examples?

Because the examples are complete projects rather than excerpts, so you can see how Prisma is wired into a specific framework. The repository includes multiple GraphQL servers built on different schema libraries, which makes it possible to compare those approaches against working code.

### Why not use prisma/prisma-examples?

Because the projects are demonstrations, not production templates. The top-level README does not document error handling, migration strategy or deployment configuration, and there are no retrieved releases, so there is no changelog or version history to pin against.

## Sources

- [Issues](https://github.com/prisma/prisma-examples/issues)
- [License: Apache-2.0](https://github.com/prisma/prisma-examples/blob/latest/LICENSE)
- [prisma/prisma-examples on GitHub](https://github.com/prisma/prisma-examples)
- [Project website](https://www.prisma.io/docs/)
- [README](https://github.com/prisma/prisma-examples/blob/latest/README.md)

---

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