Prisma is used in a variety of environments, frameworks, and workflows, serving developers with diverse needs and goals. This document defines what an operating context is, outlines our prioritization framework, and sets clear expectations for support across different environments.

By focusing on specific operating contexts, we aim to prioritize development, ensure compatibility where it matters most, and communicate transparently with our community.

What is an Operating Context?

An operating context refers to an environment or framework where Prisma is used. These include databases, runtimes, frameworks, deployment platforms, and more.

Not all operating contexts are directly supported by the Prisma ORM codebase. Some are supported through separate packages, and others may be maintained externally.

Regardless of where the support resides, the operating contexts we recognize influence our design decisions, how we respond to bug reports, and how we evaluate feature requests.

Examples of Prisma operating contexts include:

• Database Contexts: The types of databases Prisma can connect to
• Execution Contexts: The runtime environments where Prisma operates, eg Node.js
• Framework Contexts: Frameworks and libraries that developers use in conjunction with Prisma, eg Next.js, SvelteKit, or NestJS
• Deployment Contexts: The platforms or systems where Prisma-enabled applications are deployed, eg AWS Lambda, Kubernetes, or Vercel
• (and more, listed below)

Prioritization Categories

1. First-Class

These are environments and frameworks we believe deliver the highest value to our community and customers. We actively improve compatibility, release new features, and prioritize enhancements for these contexts.

• Bug Prioritization: Regressions or issues in these contexts will be resolved promptly
• Feature Requests: Relevant feature requests will be actively evaluated and prioritized based on demand and impact
• Community Contributions: are very welcome

2. Supported

These are contexts which Prisma supports, or which have previously seen development effort by the Prisma team. We aim to address regressions in these contexts and maintain existing functionality but we won’t dedicate resources to new functionality.

• Bug Handling: Regressions will be addressed
• Feature Requests: Feature requests will be politely closed, but community pull requests are welcome
• Community Contributions: Developers are encouraged to extend functionality for these contexts

3. Unofficial

These are environments Prisma does not officially support, but where third-party solutions or workarounds exist to use Prisma. We won’t accept bug reports or feature requests related to unofficial contexts. Example: Prisma Client Go

• Bug Reports and Feature Requests: Issues and feature requests related to these contexts will be closed with a polite explanation. Where possible, users will be redirected to relevant third-party repositories or community-maintained solutions.
• Community Contributions: Developers are encouraged to experiment with using Prisma in unofficial contexts and share their solutions with the community.

Community: How to Influence Prioritization

For issues relevant to a first-class or supported operating context, we consider the following factors during prioritization:

1. Criticality: How severe is the impact of the bug? Does it affect data integrity, security, etc.
2. Impact: How many people are affected, and how often does the issue occur?
3. Value Unlocked: For features or improvements, what new use cases will this enable?
4. Relevance: How many users or projects would benefit from this?

Here’s how you can influence prioritization:

• Reactions: Add a 👍 to bugs or feature requests to indicate demand
• Detailed Use Cases: Provide examples and use cases to help us evaluate the impact of your request

Enterprise Support

For organizations relying on environments or use cases that fall outside Prisma's prioritization categories, enterprise support provides an additional avenue to ensure your needs are met.

Read more about Enterprise Support here.

Database Contexts

Databases are the core of Prisma’s functionality, as it generates queries and manages schema migrations. We focus on supporting widely-used relational and document-based databases, fielding bug reports and feature requests related to compatibility and performance. Our goal is to ensure robust support for first-class databases while addressing regressions in supported ones.

First-Class (aka First Class Databases)

Prisma’s First-Class Databases (FCDBs)—PostgreSQL, MySQL, SQLite, MongoDB, and MariaDB—are prioritized for bug fixes, performance improvements, and feature development.

These databases benefit from Prisma’s powerful migration tools, type-safe queries, and seamless integration into modern workflows.

To learn more about how Prisma supports First-Class Databases, take a look at the ORM Manifesto.

• Prisma Postgres
• PostgreSQL
• MySQL
• SQLite
• MongoDB
• MariaDB

Supported

Prisma supports range of databases beyond our First-Class Databases. However, these databases are not prioritized for new features or bug fixes.

Community contributions are encouraged to enhance support, and enterprise customers can request prioritization for specific needs.

For a complete list of supported databases, see the Prisma documentation.

• SQL Server
• CockroachDB
• PlanetScale
• Neon
• Turso
• D1

Programming Language Contexts

Prisma officially targets TypeScript and JavaScript. Third party generators exist for other languages through community integrations or bindings, but may not provide the complete Prisma feature set.

We won’t fix bugs or accept feature requests for other languages, but we welcome community contributions.

First-Class

• TypeScript
• JavaScript

Unofficial

There are unofficial libraries for several other languages, including:

• Go
• Python

Execution Contexts

Execution contexts refer to the runtime environments where Prisma operates, such as Node.js or Deno. These contexts matter because compatibility issues can arise due to differences in runtime implementations. We prioritize first-class runtimes like Node.js due to their widespread use and strong alignment with Prisma’s architecture.

First-Class

• Node.js
• workerd (Cloudflare workers runtime)

Supported

• Bun

Unofficial

It’s possible to use Prisma outside our First Class and Supported environments, but it’s beyond our scope to address issues which arise.

• Deno: while we recognize its rising popularity, Deno support isn’t our priority at the moment
• Browsers

Deployment Environments

Deployment environments are the platforms where Prisma-enabled applications are hosted, including serverless and containerized solutions. While Prisma is platform-agnostic, deployment configurations can introduce issues (e.g., file access in serverless environments).

We focus on resolving issues in first-class platforms and providing guidance for supported setups (see the docs for more).

Prisma was initially developed for traditional server environments, and these remain robust deployment options. However, we actively support newer deployment platforms that align with our community’s needs.

First-Class Deployment Environments

These environments are prioritized for compatibility improvements, active support, and feature development. They align closely with Prisma’s architecture or have widespread community appeal.

• Traditional Servers
  • Heroku
  • Render
  • Koyeb
  • AWS EC2
• Serverless Functions
  • Vercel
  • Azure
  • AWS Lambda
  • Netlify
• Edge Functions
  • Cloudflare
  • Deno Deploy

Supported Deployment Environments

These platforms are compatible with Prisma but may require additional configuration or tools to work effectively. While regressions will be addressed, these environments are not a focus for new feature development.

• Google Cloud Functions
• Digital Ocean
• Fly.io
• Kubernetes (self-hosted)
• IBM Cloud

Notes on Deployment Challenges

Each deployment environment introduces specific challenges based on Prisma’s architecture:

• Connection Pooling: Serverless environments require efficient database connection management. Prisma Accelerate can help address this issue.
• Cold Starts: Serverless platforms may experience cold starts
• File System Access: Prisma utilizes filesystem access which may need workarounds on serverless platforms

For detailed deployment-specific guidance, see our deployment documentation.

Module Bundlers

Module bundlers refer to tools like Webpack, Vite, and Rollup, which package Prisma’s generated code into applications. While Prisma does not bundle code directly, compatibility issues can arise with tree-shaking, dynamic imports, or dependency resolution. We prioritize fixing issues with widely-used bundlers.

We aim to be compatible with the most popular module bundlers but you may need additional configuration. See the docs for more info.

Note that Prisma’s support for ESM is still being developed, so bundlers which require ESM support may need additional setup for now (see the docs).

Containerization and Docker Contexts

Containerization contexts refer to environments like Docker, where Prisma is packaged alongside other application components, either during development or in production. Issues can arise due to library incompatibilities or minimal base images (e.g., Alpine).

We aim to work out of the box in our first class contexts, other Docker setups may require manual tinkering.

First-Class

• Docker using node:lts and node:lts-alpine

Development Environment Contexts

Development environments cover local setups, workflows, and CI/CD pipelines used to build Prisma-powered applications. While Prisma doesn’t dictate environment configurations, issues often arise from mismatched dependencies or platform limitations. We support common setups and focus on ensuring seamless developer experiences in these environments.

First-Class

• Local Development:
  • Local PostgreSQL, MySQL, or SQLite instances
  • VS Code (Prisma VS Code Extension
• CI/CD Pipelines:
  • GitHub Actions
  • GitLab CI
  • CircleCI

Supported

• Any editor not based on VS Code that supports the language server protocol

Application Framework Contexts

Framework contexts include the tools and libraries developers use alongside Prisma to build web and backend applications.

Although Prisma doesn’t integrate deeply with most frameworks, we often address issues stemming from framework-specific patterns or conflicts. Our priority is to ensure compatibility with widely-used frameworks to minimize friction for developers.

First-Class Frameworks

These frameworks are highly adopted and prioritized for compatibility and issue resolution.

• Next.js
• SvelteKit
• Nuxt
• Remix
• Express
• Fastify
• Apollo Server

Supported Frameworks

These frameworks are compatible with Prisma, but they are not a focus for new feature development or optimizations. We address regressions and rely on community contributions for deeper integrations.

• RedwoodJS
• NestJS
• KeystoneJS
• Amplication
• Wasp
• GraphQL Yoga
• Koa
• Hapi
• Blitz JS

Something Is Missing

If you feel something is missing or underrepresented, feel free to comment here, hit us up on Discord or open a Discussion.