Vercel deploy vs Granite.so: fixed pricing for Docker apps

By Mark Hayes
Vercel deploy vs Granite.so: fixed pricing for Docker apps

A Vercel deploy is one of the nicest experiences in web development. Push a branch, get a preview URL, merge, and production updates in under a minute. For a Next.js marketing site or a frontend-heavy app, it's hard to beat.

Then you try to deploy the rest of your SaaS. The API that holds a WebSocket open. The background worker that processes uploads. The Postgres database. The docker-compose.yml that runs all of it perfectly on your laptop. Suddenly you're splitting your app into functions, picking a database from a marketplace, adding a queue vendor, and reading a pricing page with more meters than a parking garage.

This post is a fair look at how Vercel deploys work, where they shine, where a Dockerized SaaS starts fighting the model, and what the bill looks like either way. Then it shows how to run the same stack on Granite.so with a price you know before you ship.

How a Vercel deploy actually works

Vercel is a frontend cloud built around frameworks. Understanding the model explains both its strengths and its limits.

Git-driven deploys

You import a GitHub, GitLab or Bitbucket repository. Vercel detects the framework (Next.js, SvelteKit, Nuxt, Astro, Vite and many more), runs the build, and deploys the output. Every push to a non-production branch gets a unique preview deployment; pushes to the production branch update your live domain.

The CLI

You can also deploy from your terminal:

npm i -g vercel
vercel login
vercel link          # connect this folder to a Vercel project
vercel               # create a preview deployment
vercel --prod        # deploy to production
vercel env pull .env.local   # download env vars for local dev

Deploying from CI

If you want tests to gate production, the documented pattern is to build in CI and upload the prebuilt output:

# .github/workflows/deploy.yml
name: Deploy to Vercel
on:
  push:
    branches: [main]

env:
  VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}
  VERCEL_PROJECT_ID: ${{ secrets.VERCEL_PROJECT_ID }}

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-node@v5
        with:
          node-version: 22
      - run: npm ci && npm test
      - run: npm i -g vercel@latest
      - run: vercel pull --yes --environment=production --token=${{ secrets.VERCEL_TOKEN }}
      - run: vercel build --prod --token=${{ secrets.VERCEL_TOKEN }}
      - run: vercel deploy --prebuilt --prod --token=${{ secrets.VERCEL_TOKEN }}

What actually runs

Static assets go to Vercel's CDN. Server-side code (API routes, server components, server actions) runs as Vercel Functions, which are invoked per request, scale automatically, and are subject to maximum execution durations that depend on your plan and configuration. There's no long-lived server process that you own.

That last sentence is the whole story of this comparison.

Where Vercel deploys shine

Credit where it's due. Vercel is the right choice when:

  • Your app is a frontend framework app and most of the backend is thin API routes.
  • Preview deployments matter to your workflow: designers and co-founders reviewing each branch on its own URL.
  • Edge caching and image optimization make a real difference to your conversion rates.
  • You're building on Next.js and want features on day one, from the company that maintains it.

If that describes your product, stop reading and keep using Vercel. Seriously.

Where a Dockerized SaaS fights the model

Most SaaS MVPs aren't just a frontend. They look more like this:

# compose.yaml, the stack that works on your laptop
services:
  web:
    build: .
    ports: ["8080:8080"]
    env_file: .env
    depends_on: [db]
  worker:
    build: .
    command: ["node", "dist/worker.js"]
    env_file: .env
    depends_on: [db]
  db:
    image: postgres:17
    volumes: [pgdata:/var/lib/postgresql/data]
volumes:
  pgdata:

Try to map that onto a Vercel deploy and you hit a few walls.

No Docker containers

Vercel builds from source using framework presets and function runtimes. It doesn't run an arbitrary Docker image. If your backend is a Go binary, a Django app with system packages, or anything that depends on a specific base image, you're rewriting deployment logic rather than reusing the Dockerfile you already trust.

No long-running processes

The worker service above runs forever, pulling jobs from a queue. Functions are request-scoped with duration limits. You can approximate background work with cron-triggered functions or an external queue service, but that's new architecture, and usually a new vendor.

Persistent connections are awkward

WebSocket servers, long polling, and database connection pools all assume a process that sticks around. Per-request functions can open many short-lived database connections under load, which is why serverless setups typically add a connection pooler or a serverless-friendly database driver.

The database lives somewhere else

Vercel's storage options are delivered largely through marketplace integrations with third-party providers. That's convenient to set up, but it means your database is a separate vendor with its own plan, limits and bill.

A Vercel deploy is optimized for "framework app plus some functions." A Dockerized SaaS is "a few long-running processes plus a database." Neither is wrong. They're different shapes.

What drives the bill

Vercel offers a free Hobby tier, but it's intended for personal, non-commercial projects. A startup charging customers is expected to be on a paid plan, and at the time of writing the Pro plan is priced per team member, plus usage beyond the included amounts. Check Vercel's current pricing page for exact numbers, because the metering has changed more than once.

The general shape is what matters for predictability. Usage-based billing on Vercel can include dimensions like:

  • Function compute (how long and how hard your server code runs)
  • Function invocations
  • Data transfer out of the network
  • Image optimization and edge requests
  • Seats for each team member

Then add the vendors you need for everything Vercel doesn't run: a database provider, maybe a queue, maybe a separate host for your worker, maybe object storage. Each has its own free tier, its own overage rates and its own invoice.

None of this is hidden. It's all documented. The problem for a founder at MVP stage is that every one of those meters scales with things you can't forecast yet: a bot hammering an endpoint, a retry loop, or a Hacker News spike. You can set spend limits and alerts, and you should. But you can't write the bill on a sticky note before the month starts.

Head to head: same stack, two platforms

VercelGranite.so
Deploy sourceGit repo or CLI, framework-detected buildGit repo (builds your Dockerfile, redeploys on push) or Docker image
Runs Docker imagesNoYes
Long-running processes and workersNot natively; functions with duration limitsYes, it's just your container
Preview deployments per branchYes, a core featureCheck current docs
Managed PostgresThrough marketplace providersBuilt in, with automatic backups
Object storage + CDNBlob storage, CDN for static assetsS3-compatible storage with CDN, built in
ScalingAutomatic, per requestAutomatic
Pricing modelPer-seat plan plus usage metersHobby $9/mo incl. $15 usage credits; Advanced $39/mo
Vendors for full stackUsually 2–41

Moving a Docker app to Granite.so

If your stack looks like the compose file above, here's how it maps to a single platform. Each long-running service becomes something you run, and each stateful service becomes something managed.

  1. Web service → app. Connect the repo. Granite.so builds the same Dockerfile you use locally and redeploys on every push. Or deploy a Docker image you already publish to a registry.
  2. Worker → its own service. Deploy it as a separate app from the same repo. The simplest portable approach is a small Dockerfile.worker (same base, CMD ["node", "dist/worker.js"]), so the worker runs exactly as it does in docker compose.
  3. db → managed Postgres. Create the database, copy the connection string into DATABASE_URL. Backups are automatic, so the volume in your compose file stops being a single point of failure.
  4. Local files or MinIO → S3-compatible storage with CDN. Point your S3 client at the platform's endpoint via environment variables. Uploads are served from the CDN instead of through your app.
  5. Env vars. Move everything from .env into the dashboard.

Migrating existing data is standard Postgres:

pg_dump -Fc --no-owner --no-acl "$OLD_DATABASE_URL" -f app.dump
pg_restore --no-owner --no-acl -d "$NEW_DATABASE_URL" app.dump

Make sure your server reads its port from the environment and binds to all interfaces, since that's the most common first-deploy failure when leaving a function-based platform:

app.listen(Number(process.env.PORT) || 8080, "0.0.0.0");

The budget

The Hobby plan is $9 a month with $15 of usage credits included each month, which is sized for an MVP stack like this one during beta (check the pricing page for current resource rates). When you outgrow it, the Advanced plan is $39 a month. Either way, you know your baseline before you deploy, and there's one invoice instead of three or four.

The pragmatic middle path

You don't have to pick one platform for everything. A common, sensible setup:

  • Keep the Next.js frontend on Vercel, where preview deploys and edge caching earn their keep.
  • Run the API, workers, database and storage on Granite.so, where your Docker image runs unchanged and the bill is fixed.
  • Point the frontend at the API with an environment variable like NEXT_PUBLIC_API_URL, and configure CORS on the API.

This keeps the parts Vercel is great at, and moves the parts that generate unpredictable function usage and extra vendors to a platform built for long-running containers.

Pick the platform that matches your app's shape

A Vercel deploy is a great fit for framework frontends. If your product is really a Dockerized backend with a worker and a database, forcing it into functions costs you rewrite time now and bill anxiety later.

If you want your existing Docker setup, managed Postgres and CDN-backed storage in one place with a price you can predict, deploy it on Granite.so and spend the next six weeks on your beta users instead of your billing dashboard.

Keep reading

More posts tagged “Community”.
Be first in line for updates
and special pricing
Get early access to new features and exclusive discounts delivered straight to your inbox