A few months ago, I wrote an article titled “I Reduced Prisma Database Operations by 60% Without Upgrading My Database”. In that post, I shared how profiling slow queries with EXPLAIN ANALYZE helped us cut database operations on my project, Sellary (sellary.in)—a digital commerce platform for Indian creators.
Shortly after publishing it, Martin Janse van Rensburg from the Prisma team reached out with an intriguing challenge:
"Since you already use Prisma ORM, would you be up for a follow-up running Sellary on the whole Prisma platform, adding Prisma Postgres and Prisma Compute, with an AI agent doing the setup?"
Martin offered two months of trial credits and asked for an honest, unfiltered take: setup experience, developer experience, latency, pricing, and what broke along the way.
As a solo developer running an independent project, my rule is simple: you never risk customer data or production uptime on an infrastructure experiment. Sellary currently runs in production on Next.js 16 (App Router), Prisma ORM 6, and Supabase Postgres with Vercel hosting—and our hosting bill is currently $0/month.
So we established a strict ground rule: Zero risk to production. To us, "zero risk" meant far more than just creating a git branch. We set three strict rules to keep our production data 100% safe:
1. Completely Separate Database Credentials:
The staging application only ever connected to a freshly provisioned Prisma Postgres database in Singapore (sellary-staging-db). Production Supabase connection strings ( SUPABASE_DATABASE_URL / SUPABASE_DIRECT_URL) were never injected into the experiment's GitHub Secrets or staging environment. If a query went rogue, it had zero network access to production tables.
2. Sandbox External Services:
Sellary handles real money via Razorpay. For staging, payment gateways were strictly bound to test-mode keys (rzp_test_...), and webhook secrets were dummy-scoped. A complete checkout could be executed in staging without touching live payment rails or triggering creator payouts.
3. Using Dummy Secrets in GitHub Actions:
Next.js App Router analyzes routes at build time. To prevent production secrets from being needed on GitHub Actions runners (or logged in build traces), we injected mock credentials and used SKIP_ENV_VALIDATION=1 during the CI build step, keeping production secrets completely air-gapped from the build pipeline.
We created an isolated staging lab on a dedicated git branch (experiment/prisma-infrastructure), equipped an AI coding agent with official Prisma skills, and evaluated whether Prisma Postgres and Prisma Compute could run Sellary end-to-end.
Here is an honest breakdown of what worked, the friction points we hit, and the economics.
Sellary isn't a simple demo app. Our database schema contains 36 models, 28 enums, and over 1,400 lines in schema.prisma, alongside raw SQL queries with PostgreSQL-specific features like FILTER (WHERE ...) and ON CONFLICT DO UPDATE.
Because the project had evolved rapidly during early development, our migration history was behind our schema. If we had naively run prisma migrate deploy against a clean database, 32 out of our 36 tables would have been completely missing.
Rather than trying to guess, we used Prisma's migration engine to generate a clean baseline SQL script:
npx prisma migrate diff --from-empty --to-schema-datamodel prisma/schema.prisma --script > prisma/baseline.sql
The Windows Catch: If you run this in PowerShell on Windows, default redirection emits UTF-8 with a Byte Order Mark (EF BB BF). PostgreSQL's query engine rejects this with a syntax error at byte 0. We stripped the BOM using an explicit UTF-8 encoding stream before applying it.
Once applied to our Singapore staging database (ap-southeast-1), we verified parity:
npx prisma migrate diff --from-schema-datamodel prisma/schema.prisma --to-url "$DATABASE_URL"
All 36 models, indexes, and relations mapped cleanly with zero application query rewrites.
Prisma Compute runs containerized workloads powered by Bun. We configured Next.js 16 for standalone output (output: 'standalone' in next.config.ts) and defined our micro-container service using Prisma Composer in service.ts and module.ts:
import nextjs from '@prisma/composer/nextjs';
import { compute } from '@prisma/composer-prisma-cloud';
export default compute({
name: 'web',
deps: {},
build: nextjs({ module: import.meta.url, appDir: '.' }),
});
We then set up GitHub Actions using prisma/cloud-deploy-action@v1 to build and deploy on every push to our staging branch.
That is where we encountered the real-world friction.
When bridging bleeding-edge developer tools with an existing codebase, edge cases happen. Here are the three specific hurdles we encountered:
prisma deploy module.ts). In GitHub Actions, prisma/cloud-deploy-action checks if node_modules/.bin/prisma exists. Because npm ci installs Prisma 6, the action executed the local binary—which lacks the deploy verb—causing the CI runner to halt.build-command:
build-command: >-
npm run build &&
rm -f node_modules/.bin/prisma node_modules/.bin/prisma.cmd
Next.js builds cleanly with Prisma 6, unlinks the local binary, and allows the deployment step to fall back to the bundled Prisma 8 Compute CLI via Bunx.
$prismaConfig: 1 Marker Trap
prisma.config.ts by checking for an internal marker: value["$prismaConfig"] === 1. In a hybrid repo on Prisma 6, importing definePrismaConfig from @prisma/cli-engine breaks local commands like npx prisma generate.
function definePrismaConfig<T extends Record<string, any>>(config: T) {
return Object.freeze({ ...config, $prismaConfig: 1 });
}
const isComposerCommand =
process.argv.some((arg) => arg === 'deploy' || arg === 'dev') ||
Boolean(process.env.PRISMA_COMPOSER || process.env.PRISMA_DEPLOY);
export default isComposerCommand
? definePrismaConfig({
composer: composer({
extensions: [prismaCloud({ region: 'ap-southeast-1' }), nodeBuild(), nextjsBuild()],
state: prismaState(),
}),
})
: {};
Standard ORM commands receive {} (so Prisma 6's strict validator doesn't crash), while Compute commands get the valid marker.
next build static page generation. Missing live staging secrets in the build runner halted CI.SKIP_ENV_VALIDATION=1, converted SDK constructors to lazy getters, and wrapped static ISR queries in build fallbacks.
Once deployed to our staging URL in Singapore (sin.prisma.build), we ran a complete acceptance test:
User model on sellary_sid JWT cookie through Edge middleware.₹10), verifying database persistence in the Product table./product/test) to verify that the page loads real data from the database properly on The Numbers:
POST /api/v1/ping with prisma.creatorProfile.updateMany.
Everything functioned smoothly with zero application query modifications.
Now, let's talk about the cloud bill and Prisma's pricing structure.
Prisma offers a Free plan ($0/month) that includes 200,000 database operations, 2 GB of storage, and 1,000,000 Compute requests a month with no credit card required. For teams needing more capacity and backups, the Starter plan costs $10.00 / month and includes custom spend limits.
The Starter plan features:
The Catch for Independent Projects:
Additional database operations on paid plans cost $8.00 per 1,000,000 operations.
In my previous article, I showed how eliminating N+1 queries cut our operations by 60%. In an operations-metered cloud model, query optimization is directly linked to your cloud bill.
If you have 24/7 background crons (e.g., an analytics flush running every 15 minutes = 2,880 runs/month, or hourly settlement tasks), unbatched queries can chew through your operation allowance before real users even visit your site.
This naturally brings up the concern of surprise bills. Fortunately, every paid plan allows you to set a hard spend limit in the Prisma Console. You choose the exact ceiling, and your monthly bill cannot exceed that number. This completely eliminates the fear of runaway overage charges.
Still, on Supabase Free, database operations are unmetered (pooled and connection-throttled), and Vercel Hobby covers our frontend traffic with zero overage risk. For an independent project funded out of pocket, $0/month with zero surprise bill risk remains our baseline.
Testing Prisma Compute and Prisma Postgres gave us high confidence that the unified Prisma platform can run a real, full-stack Next.js 16 application end-to-end. The branch-bound database isolation and fast container initialization are fantastic for staging workflows.
Our Path Forward:
Suggestions for the Prisma Team:
install-command: none to cleanly skip dependency installation.
Huge thanks to Martin Janse van Rensburg and the Prisma team for providing trial credits, asking for an unfiltered evaluation, and supporting builders.