The Evolution of Prisma
If you are a developer, especially a front-end or a full-stack developer since before the AI era, you most definitely have heard of Object Relational Mappers (ORMs). Prisma is a company that made one of the popular ORMs, the Prisma ORM, a lightweight contract layer between your application code and your database, that allowed you to talk to your database without the need to write SQL queries.
Today, Prisma has a whole product suite that makes it easier for you to build, deploy and scale your application. It consists of Prisma Postgres, a managed PostgreSQL database on the cloud, Prisma Compute, the deploy infrastructure and Prisma Composer - a tool that sets up all the parts of your app from one file. But this wasn’t always the case.
Prisma started as a “backend as a service” company back in 2016, and it was named Graphcool, inspired (I assume) by the technology behind it — GraphQL, a then new query language to query your backend. With Graphcool, you described your data, and Graphcool created a database plus a GraphQL API for it, ran both on its own servers, and handled things like user login and file uploads. You as a developer only had to build the front of your app, which is why it was called "backend as a service”.
A couple years later, the company decided to open source the engine that powered Graphcool and release it on its own, which was called Prisma 1. This first version, Prisma 1, moved away completely from hosting your backend. You wrote your own server with your own logic, and Prisma 1 ran as another server between the code and your database, still powered by GraphQL, effectively turning the database into a GraphQL API your code could query. In 2020 the team rewrote the product from scratch as Prisma 2. There was no proxy server and no GraphQL layer anymore, just an open-source library that ran inside your application. The data was described in a schema file, and Prisma generated code to read and write it, checking your queries for mistakes before they ever run. Graphcool and Prisma 1 both were soon archived, and Prisma 2 became the Prisma ORM most developers know today. With Prisma 8 just released, the ORM has evolved quite a lot over the years, and has undergone some prominent changes, like moving away from the Rust-based client in exchange for TypeScript. Read more about the launch of Prisma 7.
What I built
As someone working in Developer Relations, I naturally have to present a lot of talks on different stages, and I often end up sharing a number of QRs and links, without ever knowing who scanned them, how and when. I have tried QRFY before, so I know exactly the features I wanted. To solve this problem, I built a similar tool called Snip, a link shortener that makes QR codes and tells me the number of scans.
The working of the app is relatively simple. You paste a link (for example, a link to your social profile), you get a QR code asset that you can download, and a standalone link you can share/forward. I had an unused domain with me that I bought off Hostinger a while ago, which I am also planning to use.
Because every scan passes through Snip first, I can see:
- how many people scanned the QR code and how many clicked the plain link
- which device and browser was used
- visits per day
- the last 20 visits, refreshing every 10 seconds, so I can watch scans come at the end of any conference/event
The tool also ignores bots. When you paste a link into LinkedIn, Slack, or WhatsApp, their servers open it to build a preview. The bots are redirected, but are left out of the counts, so I get a realistic number of scans and clicks.
I paired all of this with a simple password-protected dashboard, where I can create links, download QRs, delete old links or track the numbers for a given link.
How Snip is put together
Snip uses every part of the Prisma stack:
- Prisma ORM latest describes the data: links, visits, and daily totals.
- Prisma Postgres as the database to store the data.
- Prisma Compute runs the web app, the redirect, and the dashboard.
- Prisma Object Storage holds the QR code images.
- Composer’s scheduled jobs add up each day’s visits every 6 hours.
- Prisma Composer ties it all together in one file that describes every part above.
The Development Experience
The fairest way to test the Prisma stack’s capabilities in 2026 was the 2026 way — using a coding agent. There is no point hiding such things anymore. LLMs have gotten very good with coding over the last few years, especially with web apps. Top models now solve over 85% of the tasks on SWE-bench Verified, making them the de facto standard for writing code now and in the future to come. Prisma was quick to realize this, and is actively pushing for an agent-first development experience. The headline on their website says: “Your TypeScript app, from prompt to production”, which is true, because I was indeed able to get the first draft of my app running in under 30 minutes, with minimal human effort involved.
I used the Claude Sonnet 5.5 model with high effort settings through the Claude Code extension for VS Code.
What my agent did
My agent started with Prisma’s full-stack tutorial with a fairly simple idea — a QR tracker that will help me track scans and link-clicks. The project was easy to setup with the Prisma scaffold. The initial build was a Hono application, a PostgreSQL database, a typed ORM client, and the configuration needed to run on Prisma Compute. It built and ran the starter app locally before moving on to the actual application. There were a couple of setup snags along the way, like an npm version mismatch, but the agent handled it with ease.
After the basic setup worked, the agent replaced the tutorial’s example data with the application’s core models: links and visits. It implemented short-link redirects, QR and ordinary-link source tracking, device and browser detection, referrer capture, and bot filtering. It also built the dashboard, QR-code generation and downloads, and a scheduled job to aggregate visits by day and source.
Once the core features were in place, I asked the agent to test how the application would behave with a larger dataset. It seeded the database with 50,000 test visits across 20 links and built a load-testing script to measure response times, including the time spent executing database queries. The results revealed some performance bottlenecks, which the agent addressed by adding a composite index to help PostgreSQL find the relevant visit records more efficiently. After deploying the change and running the tests again, the median server-side query time dropped from 37.6 ms to 16.5 ms, a 56% reduction.
TIP: It is always efficient to prompt your agent to work on one feature at a time. This leads to clearer logic and fewer hallucinations, since the AI isn’t juggling multiple responsibilities at once.
After all of this, the app finally looked promising, and was ready to be deployed. Before deploying it on Prisma’s servers, I did what every engineer today is doing: write code review code. Carefully, line by line. Some more minor changes later, built the app and deployed it to Prisma Compute with npx prisma deploy module.ts. The deployment provisioned the PostgreSQL database, applied the schema migrations, configured the application’s database connection, and deployed the service. I tested the live endpoints, created a link through the dashboard, scanned some QR codes. Everything looked good. I was happy with the results.
How does Prisma help the agent do better?
Giving an AI agent access to a terminal and asking it to build an application also means giving it the right tools, up-to-date documentation, and instructions for working with your stack. After building Snip, I am confident that Prisma is taking a step in the right direction.
Protocolizing the Portfolio with Model Context Protocol (MCP)
Prisma has exposed its entire product lifecycle—from local development to cloud databases—as standard tools using Anthropic's Model Context Protocol (MCP). They do this through two key servers:
- Local Prisma MCP Server: AI agents the ability to introspect database schemas, write error-free migrations, check migration status, and launch Prisma Studio right from within code editors like Cursor or Claude Code.
- Remote Prisma MCP Server: Exposes infrastructure management capabilities. AI agents can natively provision new Prisma Postgres instances, fetch secure connection strings, manage database instances, and configure automated backups using safe, tool-calling APIs.
Read more about Prisma MCP Server here.
Handling AI Hallucinations with Prisma skills
One of the biggest challenges with AI-generated code is that models can rely on outdated APIs and patterns. Prisma addresses this with Agent Skills: structured instructions that give coding agents version-specific knowledge about its products. The skills cover everything from CLI commands and database migrations to ORM APIs and deployment workflows. Once installed, an agent can reference them automatically when working on a relevant task. Prisma Skills follow the open Agent Skills format.
You can easily add all the skills to your project by running the command:
npx skills add prisma/skills
with an option to install only the ones you need.
Documentation for agents
Having worked in technical writing, I care deeply about documentation and like to associate it with measurable outcomes, both for developer experience and, increasingly, agent experience. Documentation has always been an important part of the equation, even more so now that humans aren’t the only ones reading it. What I particularly liked about Prisma’s documentation was the availability of an llms.txt file, Markdown versions of documentation pages, and consistent semantics across most of the documentation.
During development, my agent could consult the documentation to understand how Prisma’s products worked together, investigate errors, and navigate unfamiliar parts of the stack.
Beyond these three, Prisma is also thinking about what it takes to use AI agents safely in production. Features like agent enrollment and safeguards against destructive commands help developers control what agents can access and which operations they can perform, and with native pgvector support, Prisma Postgres can also serve as the foundation for applications that use vector embeddings.
Ultimately, these pieces complement each other. They make it easier for an agent to move beyond generating code and work through the broader development lifecycle.
So, is Prisma’s Stack a perfect option for you?
Choosing Prisma for your next application comes down to a few key points. I wouldn’t call any stack a perfect fit for every project, and Prisma’s is no exception. But if you’re experimenting with AI-assisted development, or are increasingly leaning towards vibe-coded web apps, it’s worth looking at how its ORM, Postgres, and Compute fit together well. I was able to go from a simple idea to a working application, deploy it, and investigate performance bottlenecks without having to manage every piece of infrastructure myself. If you want to take a look at Snip, just let me know, and I will share the link to the GitHub repository down below. 😉
If you’re a developer who enjoys experimenting with new tools, or someone curious about what building software with AI agents looks like in practice, I’d encourage you to give it a try. Your experience will depend on the complexity of your project and how much control you want over the underlying infrastructure, but building a small project is always a good way to find out whether the stack works for you.
The easiest way to get started is with Prisma’s full-stack tutorial. It walks you through setting up an application with Prisma’s stack and gives you a starting point you can build on. Prisma Postgres and Prisma Compute both offer free plans (no credit card required), so you can experiment with building and deploying an application before committing to a paid plan.
The Prisma Postgres free plan includes 1.01 GB of storage, 200,000 database operations per month, and up to 50 databases. Compute adds a separate allowance for hosting your application: 1 million requests, 360 GB-hours of memory, 4 vCPU-hours of active CPU time, and 10 GB of outbound bandwidth per month. Your application also scales to zero when idle, so it doesn’t consume compute resources while it’s not running. These allowances are shared across your workspace. In case you outgrow the free tier, Prisma's paid plans start from $10 per month.
There are two ways to create a Prisma Postgres database from your terminal. Create a database without an account:
npx create-db@latest
or, if you already have a Prisma account, you can use the Prisma CLI to create a database directly:
npx prisma postgres create
Once your database is ready, you can connect it to your application, explore Prisma ORM, and deploy your app to Compute. If you’re using an AI coding agent, I’d also recommend setting up the relevant Prisma Agent Skills as mentioned in the section above.
My advice? Start small, get something running, and then see how far you can take it. You don't need an ambitious idea to explore the stack. I started with a simple QR tracker, and it turned into a useful experiment I will probably continue to use.
That concludes my thoughts on Prisma’s latest developments. These are interesting times for software development, and it is good to see a company adapt early.
Thank you for reading if you made it till here. Please check out other articles I have written, and if this one helped you in any way, consider subscribing. It’s free. If this blog even remotely motivated you to try (or retry) Prisma, I would love to hear your thoughts on how it went. The comments are open. :)
Top comments (0)