DEV Community: Phat Tran

How far does PocketBase Cloud's free tier actually go? I built something using only the free plan

Phat Tran — Tue, 21 Jul 2026 17:09:12 +0000

Free tiers on hosting platforms usually share the same pattern: fine for a demo, but the moment you actually try to use one you hit a wall. This post isn't just talk — I built a small real project using nothing but PocketBase Cloud's free plan, start to finish, to see how far it actually goes.

What's in the free plan

PocketBase Cloud's free plan includes:

1 PocketBase instance (50MB disk limit)
5 frontend deployments (no custom domains on free — that starts at the Starter plan)
Runs on a dedicated server cluster reserved for free plan users

One thing people often ask: why does a free plan still need a Stripe card? It's a $0 subscription used purely for verification and abuse prevention (stopping people from spamming hundreds of instances) — you're never actually charged.

No rate limits like PocketHost enforces, and no hibernation — the free instance runs 24/7 with no cold starts. That's the biggest difference from most other free tiers out there, which tend to hibernate idle instances to cut costs.

Demo project: a mini link shortener

To test this properly, I built a small link shortener — a mini bit.ly — using only:

1 PocketBase instance (free) for the database + API + auth for the admin page
1 frontend (free) — a simple React app, deployed as a static site

Schema

A links collection:

slug (text, unique)
target_url (url)
clicks (number, default 0)
owner (relation to users, optional)

Create rule: @request.auth.id != "" — only logged-in users can create links. List/view rules are left public, since a link shortener needs to redirect for anyone, logged in or not.

Redirect logic via a hook

This is where hooks (PocketBase's embedded JS VM) earn their keep — no separate backend needed:

routerAdd("GET", "/r/{slug}", (e) => {
  const slug = e.request.pathValue("slug")
  const record = e.app.findFirstRecordByFilter("links", `slug = "${slug}"`)

  if (!record) {
    return e.notFoundError("Link not found")
  }

  record.set("clicks", record.get("clicks") + 1)
  e.app.save(record)

  return e.redirect(302, record.get("target_url"))
})

This route runs right inside the instance — no extra backend service to deploy. Backend hosting (Node/Deno/Bun) is Pro-plan-only anyway, so hooks are exactly how you get custom logic on the free plan without paying for anything extra.

Frontend

A small React page: a form to create links, a list showing click counts. No custom domain (not available on free), so it runs on the default subdomain you get assigned.

Where you actually hit the limits

After building it and stress-testing with some sample data:

50MB disk: with a schema that's mostly text/number fields, you can fit tens of thousands of records before hitting the ceiling — plenty for a demo, an MVP, or a genuinely small personal project. If you're storing files (images, video), 50MB disappears fast, and the free plan won't be enough for anything file-heavy.
1 instance: if you need separate staging/production databases, or a multi-tenant setup with one instance per client, the free plan won't cut it — that's when it's time to look at the Starter plan.
No custom domain: fine for an internal MVP or a demo you send to a client, but a real product launching publicly will almost certainly need its own domain.

Who this free tier actually makes sense for

The free plan isn't meant for serious production traffic — that's true of pretty much every free tier out there. But unlike many free tiers that hibernate instances or throttle requests to the point of being barely usable, here you get:

A genuinely running instance, 24/7, no cold starts, so you can evaluate the real experience before paying anything
Enough to demo to a client, run a personal side project, or just learn PocketBase without spinning up your own VPS

If you're on the fence about trying PocketBase Cloud, the free plan is the cheapest way to find out for yourself — no real charge on your card, and building something small like this takes about 15–20 minutes to know whether it fits what you need.

Try it at pocketbasecloud.com.

Have you built anything on a hosting platform's free tier before — did it actually hold up, or was it just a demo before the upgrade prompt?

PocketBase Cloud vs PocketHost — which one should you deploy PocketBase on?

Phat Tran — Tue, 21 Jul 2026 16:49:46 +0000

If you're running PocketBase and looking for managed hosting instead of babysitting your own VPS, you've probably run into two names: PocketHost and PocketBase Cloud. Both let you deploy PocketBase in minutes with zero Docker or Nginx config. But under the "managed hosting" label, they're solving pretty different problems.

Full disclosure: I built PocketBase Cloud, so this isn't 100% neutral — but I'll stick to concrete numbers so you can judge for yourself.

Rate limits — the biggest difference

PocketHost enforces several layers of rate limiting at the Cloudflare edge:

50 requests / 10 seconds / IP
1,000 requests / hour / IP
10,000 requests / hour / instance
5 concurrent requests / IP
50 concurrent requests / instance

That's fine for a side project, but if you're running SSR (Next.js, Nuxt, etc.) or a backend proxy that talks to PocketBase from a single server, all your traffic comes from one IP. That "5 concurrent requests per IP" cap suddenly becomes a real bottleneck, not a theoretical one.

PocketBase Cloud doesn't enforce per-IP or per-instance caps. Throughput depends entirely on the server resources you're on — a Pro plan instance with 2 vCPU / 4GB RAM can handle 1,000+ requests per second with no artificial ceiling.

Hibernation — does your cron job actually fire on time?

This is the one people usually don't notice until it bites them. PocketHost instances can hibernate during periods of inactivity. When that happens:

Cron jobs and scheduled tasks may fail to run
The first request after waking up can be delayed or fail outright
Missed cron intervals are not replayed after wake-up

For an app with steady traffic this barely matters. But for a low-traffic B2B app, or anything relying on cron for emails, syncing, billing, etc., hibernation is a quiet risk sitting in the background.

PocketBase Cloud runs 24/7 — no hibernation, no cold starts. It behaves exactly like PocketBase on your own server, except we handle the infra, monitoring, and security hardening for you.

Not just PocketBase hosting

This is more of a product philosophy difference than a feature checklist. PocketHost is single-purpose: it only hosts PocketBase. PocketBase Cloud is a full application platform — within the same project you can deploy:

PocketBase — database, auth, realtime
Backend services (Node.js, Deno, Bun) — for logic that goes beyond what PocketBase hooks can do, or when you need something from the JS ecosystem
Static sites / frontends — React, Vue, Svelte, Astro, etc., with custom domains

Everything in the project shares the same infrastructure and can talk to each other directly — no CORS workarounds, no billing scattered across three different providers.

Quick comparison

Feature	PocketBase Cloud	PocketHost
Request rate limits	None (based on server resources)	Per-IP / per-instance caps
Hibernation	No — 24/7 uptime	Yes
Free plan	1 PocketBase + 5 frontends	No
Static site hosting	Yes, custom domains	No
Backend hosting (Node/Deno/Bun)	Yes (Pro plan)	No
Multi-service in one project	Yes	PocketBase only
Custom domains	Starter plan and up	No
Real-time log streaming	Yes	No
Server monitoring (CPU/RAM/disk)	Yes (Pro plan)	No

So which one should you pick?

If you're running a small side project with low traffic and don't care about cold starts, PocketHost is a fine, simple choice.

If you need real production reliability, have SSR/proxy traffic funneling through one IP, rely on cron jobs, or want your frontend + backend + database in one place instead of juggling three providers — that's exactly the gap PocketBase Cloud was built to fill.

PocketBase Cloud has a free plan (1 PocketBase instance + 5 frontend deployments), no credit card required to actually try it — check it out at pocketbasecloud.com.

Where are you hosting PocketBase right now — self-hosted, PocketHost, Coolify, something else? Curious to hear how it's going for you 👇

How I Edit Hooks and Add Routes on PocketBase Cloud

Phat Tran — Thu, 16 Jul 2026 08:25:42 +0000

Extending with Hooks

PocketBase hooks let you run custom JavaScript on the server — right inside your instance. Add API routes, react to record changes, schedule cron jobs, or send emails, all without deploying a separate backend.

On PocketBase Cloud, you write and manage hooks directly in the dashboard: open your instance and go to the Hooks tab.

Creating a hook

Open your PocketBase instance in the dashboard
Go to the Hooks tab
Click New Hook, give the file a name ending in .pb.js (e.g., main.pb.js)
Write your code and save — the instance reloads hooks automatically

Example: a custom API route

routerAdd("GET", "/api/hello/{name}", (e) => {
  const name = e.request.pathValue("name");
  return e.json(200, { message: `Hello ${name}!` });
});

Your route is immediately available at:

https://<instance-name>.pocketbasecloud.com/api/hello/world

Example: react to record changes

Run logic whenever a record is created, updated, or deleted:

onRecordCreate((e) => {
  // runs before the record is persisted — you can still modify it
  e.record.set("slug", e.record.get("title").toLowerCase().replaceAll(" ", "-"));
  e.next();
}, "posts");

onRecordAfterCreateSuccess((e) => {
  // runs after the record is saved
  console.log("new post:", e.record.id);
  e.next();
}, "posts");

Example: scheduled cron jobs

cronAdd("cleanup", "0 3 * * *", () => {
  const records = $app.findRecordsByFilter(
    "sessions",
    "created < @yesterday",
    "-created",
    200,
    0
  );

  for (const record of records) {
    $app.delete(record);
  }
});

Example: send an email

onRecordAfterCreateSuccess((e) => {
  const message = new MailerMessage({
    from: { address: e.app.settings().meta.senderAddress },
    to: [{ address: e.record.email() }],
    subject: "Welcome!",
    html: "<p>Thanks for signing up.</p>",
  });

  e.app.newMailClient().send(message);
  e.next();
}, "users");

What hooks can access

Hooks run in PocketBase’s embedded JavaScript VM with access to:

$app — the full PocketBase app instance (query, create, update records)
routerAdd — register custom HTTP routes
onRecord* event handlers — before/after create, update, delete
cronAdd — cron-style scheduled jobs
$http.send() — make outbound HTTP requests to third-party APIs
$os, $filesystem, $security — utility namespaces

See the PocketBase JSVM documentation for the complete API.

When to use a backend instead

Hooks are perfect for lightweight logic tied to your data. For heavier workloads — long-running jobs, large dependencies, websockets, or code you want to develop and test locally as a normal project — deploy a dedicated backend alongside your instance.

You can deploy and manage PocketBase instances, hooks, environment variables, backups, and custom domains from the PocketBase Cloud dashboard.

How to Use Environment Variables in PocketBase Hooks

Phat Tran — Fri, 10 Jul 2026 04:20:31 +0000

API keys, webhook secrets, and third-party credentials should never be hardcoded
inside your PocketBase hooks.

Instead of writing this:

const apiKey = "re_live_your_real_secret";

you can store the value as an environment variable in PocketBase Cloud and read
it only when your server-side hook runs.

In this tutorial, you will:

add an environment variable from the PocketBase Cloud dashboard;
access it from a PocketBase JavaScript hook;
verify that the variable is available without exposing its value; and
update or remove it later.

Prerequisites

Before starting, you need:

a PocketBase Cloud account;
a project with a running PocketBase instance; and
access to the Hooks and Environment Variables pages for that instance.

You do not need SSH access to the server, and you do not need to upload a
.env file manually.

Open the Environment Variables page

Open Projects.
Select your project.
Open the PocketBase instance you want to configure.
Select Environment Variables from the instance sidebar.

This page lists the environment variables attached to the selected PocketBase
instance.

Add an environment variable

Select Add Variable.

For this tutorial, create the following example variable:

Key: RESEND_API_KEY
Value: re_your_example_key

Use a fake value while testing. Never include a real API key in screenshots,
public repositories, support messages, or blog posts.

Environment variable keys must:

start with an uppercase letter or underscore;
contain only uppercase letters, numbers, and underscores; and
not contain spaces.

Examples of valid keys include:

RESEND_API_KEY
STRIPE_SECRET_KEY
DISCORD_WEBHOOK_URL
INTERNAL_API_TOKEN

Select Add Variable to save it. PocketBase Cloud synchronizes the variable
with the instance and restarts the PocketBase service so that the new value is
available to hooks.

The restart may take a few seconds.

Read the variable from a PocketBase hook

PocketBase JavaScript hooks do not run in Node.js. They run in PocketBase's
embedded JavaScript runtime, so process.env.RESEND_API_KEY is not the correct
API here.

Use PocketBase's $os.getenv() helper instead:

const apiKey = $os.getenv("RESEND_API_KEY");

$os.getenv() returns the current value as a string. If the variable does not
exist, it returns an empty string.

You can find more information in the
PocketBase JavaScript overview and
the $os.getenv() reference.

Create a hook to verify the configuration

Return to your PocketBase instance and open Hooks from the sidebar.

Create a file named:

env-check.pb.js

Add the following code:

routerAdd("GET", "/api/env-check", (e) => {
  const apiKey = $os.getenv("RESEND_API_KEY");

  return e.json(200, {
    configured: !!apiKey,
  });
});

This route only reports whether the variable exists. It does not return the
secret itself.

Save the hook and make sure it is active.

Test the hook

Call the new route using your PocketBase instance domain:

curl https://YOUR_POCKETBASE_DOMAIN/api/env-check

If the variable is configured, the response will be:

{
  "configured": true
}

The response confirms that the hook can access the variable without sending
the secret to the client.

Use the variable in a real hook

After confirming that the variable is available, you can use it when calling a
third-party API.

The following example shows the general pattern:

routerAdd("POST", "/api/send-message", (e) => {
  const apiKey = $os.getenv("RESEND_API_KEY");

  if (!apiKey) {
    throw new InternalServerError(
      "The email service is not configured",
    );
  }

  const response = $http.send({
    url: "https://api.example.com/v1/messages",
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      message: "Hello from PocketBase",
    }),
  });

  return e.json(response.statusCode, response.json);
});

Replace the example URL and request body with the API you are integrating.

The important part is that the credential comes from $os.getenv() instead
of appearing in the hook source.

Update an environment variable

To rotate a credential or change its value:

Return to Environment Variables.
Select Add Variable.
Enter the existing key, such as RESEND_API_KEY.
Enter the new value and save it.

Saving an existing key updates its value. After the PocketBase instance
restarts, hooks will read the new value automatically. You do not need to
change the hook source.

Delete an environment variable

To remove a variable, select the delete button next to its key and confirm the
action.

Your hook should always handle a missing variable safely:

const apiKey = $os.getenv("RESEND_API_KEY");

if (!apiKey) {
  throw new InternalServerError(
    "The email service is not configured",
  );
}

This produces a controlled error instead of allowing the hook to make an
invalid request with an empty credential.

Troubleshooting

The endpoint returns `configured: false`

Check the following:

The key in the dashboard is exactly RESEND_API_KEY.
The key passed to $os.getenv() uses the same spelling and capitalization.
The environment variable was saved successfully.
The PocketBase instance has finished restarting.
The hook file is saved and active.

`process.env` is undefined

PocketBase hooks do not run in Node.js. Use:

$os.getenv("YOUR_KEY")

instead of:

process.env.YOUR_KEY

The hook worked before the variable was changed

Wait a few seconds for the instance restart to finish, then call the endpoint
again. Also confirm that the variable key was not accidentally changed.

You are ready

You can now manage credentials from the PocketBase Cloud dashboard and access
them safely from PocketBase JavaScript hooks using $os.getenv().

This keeps secrets out of your source code and makes credential rotation much
easier: update the value in the dashboard, wait for the instance to restart,
and your existing hooks will use the new credential automatically.

How to deploy your first PocketBase instance on PocketBase Cloud

Phat Tran — Fri, 03 Jul 2026 05:26:20 +0000

Why I chose PocketBase Cloud

If you haven't used PocketBase: it's an open-source backend in a single Go binary. Embedded SQLite, auth, real-time subscriptions, file storage, REST API, admin UI — all included.
The catch has always been hosting it: renting a VPS, configuring a reverse proxy, SSL, backups, monitoring.

That's exactly the gap PocketBase Cloud fills. It's a hosting platform built specifically for PocketBase: you click a button and get a fully managed instance — deployed on real infrastructure, secured with SSL and DDoS protection, backed up, and monitored — live in about 30 seconds, with a free plan to start. Think Vercel, but for your PocketBase backend.

This post walks through creating your first instance on it, start to finish.

I looked at a few hosts and went with PocketBase Cloud for three reasons:

Free plan to test with — 1 instance, 50 MB storage, no charge. (Heads-up: it asks for a Stripe subscription at $0 to verify you're human. You don't get billed.
6 regions — Germany ×2, Finland, US East/West, Singapore. My users are mostly in Asia, so Singapore was the deciding factor.
SSL, DDoS protection, and backups are automatic.

The Pro plan is also interesting if you hoard side projects like I do: from $13/mo you get a dedicated server with unlimited instances, so 10 projects cost the same as 1.

Step 1: Sign up and create a project

Go to portal.pocketbasecloud.com, sign up, complete the $0 Stripe step.

Create a Project, then open its PocketBase tab.

Step 2: Create the instance

Click New PocketBase. The form has three sections:

General Information

Instance Name — this becomes your subdomain, so keep it short. I used my-pocketbase → https://my-pocketbase.pocketbasecloud.com
Description — optional, skipped it
PocketBase Version — v0.39.3 was the latest when I did this. Take the latest unless you have a reason not to.

Admin Credentials

Admin email + password (12–20 chars). These are for the PocketBase admin dashboard, the same /_/ login you know from self-hosting.
There's a copy button next to the password field — copy it into your password manager before clicking Create.

Location

Pick the region closest to your users. I picked Singapore.

Click Create.

Step 3: Provisioning

You get a live progress screen while it:

picks a server based on current capacity
provisions the instance and assigns a port
sets up DNS
issues the HTTPS cert

Your backend is now at:

https://<instance-name>.pocketbasecloud.com

Step 4: Log in and sanity-check it

The admin panel is where it always is:

https://<instance-name>.pocketbasecloud.com/_/

Log in with the credentials from Step 2. It's a completely standard PocketBase admin UI — collections, users, API rules, logs.

I created a todos collection, added a record, and hit it from the browser console:

import PocketBase from 'pocketbase';

const pb = new PocketBase('https://my-pocketbase.pocketbasecloud.com');

const todos = await pb.collection('todos').getFullList();

// real-time works out of the box, no extra config
pb.collection('todos').subscribe('*', (e) => {
  console.log(e.action, e.record);
});

Final thoughts

After using PocketBase Cloud for a while, I found that it makes starting a side project much simpler. Instead of spending time setting up servers, SSL, and backups, I can jump straight into building the product.

If you're already using PocketBase—or you're thinking about trying it for your next project—I recommend giving PocketBase Cloud a try. The free plan is more than enough to explore the platform and see whether it fits your workflow.

I hope this guide helps you get started a little faster. If you end up trying it, I'd love to hear what you think. Happy building! 🚀