When Netlify Is Still the Right Choice

Be honest with yourself first. If your project is a marketing site, a blog or docs, Netlify is good at that. It builds your site on every push, gives every pull request a deploy preview, and has built-in form handling: you turn on form detection, add a data-netlify="true" attribute to a <form> tag, and submissions show up in the dashboard. Since April 2026, form submissions are free on its credit plans.

If that is all you need, you do not have to move. The rest of this post is for when the backend becomes the main part of the app.

Where Indian Teams Outgrow Netlify

A Backend That Has to Keep Running

Netlify runs backend code as functions. Its functions reference lists a 60-second limit for a normal function, 30 seconds for a scheduled function and 15 minutes for a background function. A function responds and finishes, so it cannot hold a WebSocket open or keep a queue consumer alive.

Netlify announced Netlify Server on 10 November 2026: a long-running Node.js process that can hold WebSockets. It is in Early Access. Netlify’s docs say it always scales to zero after 5 minutes without requests, runs one instance on the Free and Personal plans, and does not run Next.js, Astro or Nuxt yet. Netlify itself describes it as meant for “evaluation, experimentation, and low-volume production use”.

No India Region for Functions or Servers

New Netlify functions run in cmh (US East, Ohio) by default, per the Netlify functions configuration reference. The self-serve region list has Singapore and Tokyo in Asia, but no India region, and changing the region needs a Pro or Enterprise plan. Netlify Server supports only Ohio and Frankfurt today.

For a user in Pune, every API call then travels to the US or Singapore and back, and so does every query if your database sits next to the function.

Credits That Can Pause Every Site

Accounts created on or after 4 September 2025 are on credit-based plans. The Free plan gets 300 credits a month as a hard limit. The Netlify billing FAQ for credit plans says that when the credits are used up, “all of your web projects (sites/apps) are paused” and visitors see a Site not available page. One busy project pauses all of them, and the Free plan cannot buy more credits, so you upgrade or wait for the next cycle.

Dollar Billing for an Indian Business

Netlify plans are priced in US dollars, and its billing FAQ lists credit cards, Apple Pay and Google Pay as payment methods. We did not find a Netlify page about GST, a GSTIN field or rupee invoices. If you pay a foreign host as a business, read how reverse charge works on foreign hosting before your next filing.

Static Site, API and Postgres in One Place

On Voroa, each part of the app is its own service in one workspace, all in Mumbai:

• Static site. Your built frontend, served as files. Static sites are free to host and do not use the free tier’s running hours. See static site hosting on Voroa.
• Web service. Your Express, Fastify, Django or Next.js server as a normal long-running process. Voroa sets PORT, so a server that reads process.env.PORT works as it is. Paid sizes never sleep, and a web service can hold WebSocket connections open.
• PostgreSQL. A managed Postgres database in Mumbai, close to the API that queries it.
• Workers and cron. A queue consumer runs as a background worker, and a nightly job runs as a scheduled task instead of a 30-second function.

With auto-deploy on, each push builds a new release, the new release starts before the old one stops, and you can roll back in one click.

Netlify vs Voroa at a Glance

Netlify prices and limits were taken from its pricing page and docs on 14 November 2026. They change, so check again before you decide.

What Netlify Credits Cost Compared With Rupee Prices

Netlify’s pricing page lists these rates: 15 credits per production deploy, 20 credits per GB of bandwidth, 10 credits per GB-hour of compute and 2 credits per 10,000 web requests. Personal is $9 a month with 1,000 credits; Pro is $20 a month with 3,000 credits and unlimited members.

Do the arithmetic for a small app. Twenty production deploys a month use 300 credits, which is the whole Free plan. One deploy a day plus 30 GB of bandwidth comes to at least 1,050 credits before web requests and compute, already over the 1,000 in Personal, and the rest is paid through credit packs.

Voroa prices a service by its size, in rupees, and deploys are not charged one by one: the Free plan includes 500 build minutes a month. It has limits too. Free services stop when the workspace uses its 750 free hours or its 5 GB of bandwidth for the month. A static site is free to host. A paid web service starts at Rs 298/month and a paid PostgreSQL size at Rs 299/month, both plus GST. Our Netlify pricing breakdown for India works through more bills, and the Voroa pricing page lists every size.

What Voroa Static Sites Do Not Do

Know this before you move. A Voroa static site serves the files in your repository as they are. No build runs. Commit your dist or build folder, or deploy the same repository as a web service if you want the build to run on every push.

There is also no _redirects file and no rewrite rules yet. If someone opens /dashboard directly on a single-page app, they get a 404. Use hash routing, or run the app as a web service that answers every path. There is no built-in form handling either: point your forms at an endpoint on your own API.

How to Move From Netlify to a Netlify Alternative

1. List what Netlify does for you. Check netlify.toml and the dashboard for functions, scheduled functions, forms, redirects and environment variables.
2. Build the frontend. For a Next.js site, output: 'export' in next.config.js writes static files to out, as the Next.js static export guide explains. Commit that folder and follow the static site deploy guide.
3. Turn functions into routes. Each function in netlify/functions/ becomes a route in one Express or Fastify app. Deploy it as a web service with the Node.js guide.
4. Move scheduled functions to cron and long jobs to a background worker.
5. Copy environment variables, test on the Voroa URLs, then move your domain.

You do not have to move everything at once. You can keep the marketing site on Netlify and point it at an API and database in Mumbai. Our Vercel alternative guide covers the same split for a Next.js app. If you are moving paid workloads, you can also apply for migration credits, granted by hand up to Rs 10,000.

FAQ

Does Netlify have servers in India?

Not for compute you can choose. Netlify’s function region list has no India region, and Netlify Server runs in Ohio or Frankfurt. Functions default to Ohio.

What happens when a Netlify Free plan runs out of credits?

Netlify’s billing FAQ says every project on the team is paused and visitors see a Site not available page. You can upgrade to a paid plan or wait until the next billing cycle starts.

Can I keep my frontend on Netlify and run the API on Voroa?

Yes. Deploy the API as a web service, allow your Netlify domain in the API’s CORS settings in your code, and call it from the frontend. The browser talks to the API in Mumbai directly.

Does a free Voroa service sleep?

A free web service with a health check path can sleep after 15 minutes without requests, and wakes on the next one. Static sites, workers, cron jobs and paid sizes never sleep. The idle sleep guide lists every case.

Run Your Whole Stack in Mumbai

Put the static site, the API, the worker and the database in one workspace in Mumbai, on one rupee bill with a GST invoice. Start free with a static site, then add a web service when the backend needs to keep running.

All Netlify limits below are from Netlify’s own documentation as of November 2026, mainly its functions configuration reference. Netlify changes these numbers over time, so check their docs before you design around one.

Can you host a backend on Netlify?

Yes, with conditions. Netlify runs backend code as functions: short-lived handlers that start for a request and stop after it. A normal request can run for 60 seconds, a background task for 15 minutes, and a scheduled task for 30 seconds. A long-running Node.js server is only available through Netlify Server, which is in Early Access.

So the honest answer depends on what “backend” means for your app. A contact form, a payment webhook or a small JSON API fits well. A chat server, a queue consumer, a job that takes 40 minutes, or an API that keeps a pool of database connections open does not fit functions, and needs either Netlify Server or a host that runs ordinary processes.

The five places backend code can run on Netlify

Netlify has five different runtimes, and each has its own rules. Mixing them up is the most common reason a backend works on a laptop and fails after deploy.

Synchronous functions

This is the default. A function gets a Request and returns a Response. Netlify lists the synchronous execution limit as 60 seconds and marks it as not configurable. A buffered request or response can be up to 6 MB, and binary uploads are Base64-encoded, which brings the real upload limit closer to 4.5 MB. Functions get 1 GB of memory by default; raising it (up to 4 GB) is a Pro and Enterprise setting.

Older answers on Netlify’s forum give lower limits. The limit has moved over time, so trust the current docs, not an old thread.

Background functions

Add background: true and the function can run for up to 15 minutes. The catch: the caller gets an empty 202 straight away, so the result has to go somewhere else, such as a database row the frontend polls. If the function throws, Netlify retries it after one minute and again two minutes later, so the work must be safe to run twice. The request payload for a background function is capped at 256 KB.

Scheduled functions

A scheduled function runs on a cron expression, has a 30-second limit, and runs in UTC. It cannot receive a payload, cannot be called by URL, and only fires for published deploys, not previews. For Indian teams the UTC part matters: 0 9 * * * is 2:30 PM IST, not 9 AM.

Edge functions

Edge functions run close to the visitor but get 50 ms of CPU time per request. They are built for rewriting a request or a response, not for running your API.

Netlify Server

Netlify Server is the newest option and the one that changes the answer most. It runs a normal Node.js server (Express, Hono or Fastify) without a wrapper, keeps state in memory between requests, and holds WebSocket connections open. The limits are worth reading before you plan around it:

• It is in Early Access. Netlify says it is “meant for evaluation, experimentation, and low-volume production use”, and that its APIs and behaviour might change.
• It always scales to zero: an instance stops after 5 minutes without requests. There is no always-on setting yet.
• It runs up to 3 instances, or 1 on the Free and Personal plans.
• An instance is replaced after 8 hours even when busy, and an outbound connection, such as one to your database, is closed after 60 seconds with no traffic.
• It runs in two regions only: US East (Ohio) and EU (Frankfurt).
• Full-stack frameworks such as Next.js and Astro do not run on it yet.

As of November 2026 it is free during Early Access, and Netlify says pricing in credits will be announced before general availability.

Running Express on Netlify Functions

Netlify’s own Express guide uses the serverless-http package to turn the whole app into one function:

// netlify/functions/api.js
import express, { Router } from "express";
import serverless from "serverless-http";

const api = express();
const router = Router();

router.get("/hello", (req, res) => res.send("Hello World!"));
api.use("/api/", router);

export const handler = serverless(api);

# netlify.toml
[functions]
  external_node_modules = ["express"]
  node_bundler = "esbuild"

[[redirects]]
  force = true
  from = "/api/*"
  status = 200
  to = "/.netlify/functions/api/:splat"

Netlify’s guide is clear that every function limit still applies, and that Express should not be deployed as a background or scheduled function.

What breaks when an Express app becomes a function

Your Express code does not change, but the way it runs does. These are the problems people hit most.

Memory does not survive between requests

A function instance can be reused or thrown away at any time. An in-memory session store, a rate-limit counter in a JavaScript object, or a cache in a global variable will look fine in testing and then lose data in production. Keep state in a database, a key value store or a cookie.

WebSockets have nowhere to live

A function answers one request and ends, so it cannot hold a socket open. Socket.IO and the ws module need a process that stays up. On Netlify, that means Netlify Server, or a separate managed WebSocket service with a function that only issues tokens, which is the approach Netlify’s own blog describes.

Long jobs hit the wall

Generating a large report, resizing a batch of images or calling a slow AI API can pass 60 seconds. Moving it to a background function buys 15 minutes, but you lose the response. Anything longer, or anything that should keep working through a queue all day, needs a worker process.

Database connections pile up

PostgreSQL gives every connection its own process and memory. When many function instances each open their own connection, the database runs out of slots long before it runs out of capacity. Use a connection pooler in front of the database if your backend stays on functions.

The first request is slow

A function that has not run recently has to start before it can answer. A reply on Netlify’s forum to a user asking for an India region in 2023 said cold starts, not distance, were the cause of the slowness that user saw. On a backend built from many small functions, this adds up.

Databases for a Netlify backend

Netlify now has three answers for data:

• Netlify Database: managed Postgres, built in. Netlify’s launch post says its partnership with Neon powers the new databases. It is on credit-based plans only. The Free plan allows 1 compute unit per database, 48 compute units per billing period and 5 GB of storage, and the database sleeps after 5 minutes of no queries. Netlify says waking it typically adds “well under a second, but this is not guaranteed”. Only Pro and Enterprise can keep it always on. Netlify’s docs do not say which region it runs in.
• Netlify Blobs: a key/value store for files and unstructured data. Netlify describes it as optimised for frequent reads and infrequent writes, with no concurrency control: the last write to a key wins. It is not a relational database.
• An external database: any Postgres you can reach over TLS.

Whichever you choose, put the database in the same region as the code that queries it. A single API request often runs several queries one after another, and every one of them pays the round trip.

Where Netlify runs your backend, seen from India

Netlify’s CDN serves static files from many locations, but backend code runs in one region you pick.

• Functions default to US East (Ohio). Changing the region is a Pro and Enterprise feature.
• The self-serve function regions in Asia are Singapore, Tokyo and Sydney. There is no India region in the list.
• Netlify Server runs in Ohio or Frankfurt only.

For an app with users in India, that means every API call travels to another country and back. If the function also talks to a database in a third place, each query adds another long round trip. Moving the function to Singapore helps; it does not remove the distance.

The common split: frontend on Netlify, backend elsewhere

You can keep what Netlify does best, which is building and serving the frontend, and run the API, database and workers on a platform built for long-running processes. The frontend calls the API over HTTPS.

Two small changes make the split work. First, the frontend reads the API address from an environment variable set in Netlify’s site settings, so you never hard-code it:

// frontend, built with Vite
const API_URL = import.meta.env.VITE_API_URL; // e.g. https://api.example.in

const res = await fetch(`${API_URL}/api/orders`, { credentials: "include" });

Second, the API allows the frontend’s exact origin, including https://:

// server.js on the backend
import cors from "cors";

app.use(cors({
  origin: ["https://example.in", "https://your-site.netlify.app"],
  credentials: true,
}));

If you are weighing a full move instead of a split, the Netlify alternatives for Indian teams post compares the options.

If you use cookies across two domains, put the API on a subdomain of your main domain (for example api.example.in), so the browser treats the cookie as same-site.

Running the backend, Postgres and workers in Mumbai

This is where Voroa fits. Each Netlify runtime has a direct equivalent that runs as a normal process in Mumbai:

Turn the function back into a server

Split the Express app from the way it is started. Then the same app can run as a server on Voroa and, while you migrate, still as a Netlify function:

// app.js - your routes, unchanged
import express from "express";
export const app = express();
app.use(express.json());
app.get("/api/health", (req, res) => res.json({ ok: true }));

// server.js - the start command on Voroa: node server.js
import { app } from "./app.js";

const port = process.env.PORT || 3000;
app.listen(port, "0.0.0.0", () => console.log(`listening on ${port}`));

Voroa sets PORT for you, so reading it is all the server needs. The steps for a first deploy are in the Node.js deploy guide, and the Node.js documentation covers the runtime itself. Express’s own production best practices apply as they would on any server, such as setting NODE_ENV=production.

Add WebSockets to the same service

A Voroa web service accepts WebSocket connections on the same port as HTTP. With the ws module:

import { createServer } from "http";
import { WebSocketServer } from "ws";
import { app } from "./app.js";

const server = createServer(app);
const wss = new WebSocketServer({ server, path: "/ws" });

wss.on("connection", (ws) => {
  ws.on("message", (msg) => ws.send(`echo: ${msg}`));
});

server.listen(process.env.PORT || 3000, "0.0.0.0");

A connection with no traffic for about 100 seconds can be closed on its way through the edge, so send a ping every 30 seconds and reconnect after a deploy. The WebSockets guide has the full client side.

Replace background functions with a worker

A worker has no web address. It runs your start command and keeps running, which suits a job queue. Here is a minimal one that uses a Postgres table as the queue, so it needs nothing beyond the database:

// worker.js - start command: node worker.js
import pg from "pg";
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });

async function next() {
  const { rows } = await pool.query(`
    UPDATE jobs SET status = 'running'
    WHERE id = (
      SELECT id FROM jobs WHERE status = 'queued'
      ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1
    )
    RETURNING *`);
  return rows[0];
}

for (;;) {
  const job = await next();
  if (!job) { await new Promise((r) => setTimeout(r, 2000)); continue; }
  await handle(job); // your slow work, no 15-minute cut-off
  await pool.query("UPDATE jobs SET status = 'done' WHERE id = $1", [job.id]);
}

The API inserts a row and answers at once; the worker picks it up. SKIP LOCKED lets you run more than one worker without two of them taking the same job. Voroa’s background workers cost the same as a web service of the same size.

If a job is meant to run and finish on a timetable instead, use a scheduled task or a cron job, not a worker. A worker that exits gets started again. The guide on choosing between a worker and a cron job explains the difference.

Put Postgres next to the API

Create a managed PostgreSQL database in India and set its URL as DATABASE_URL on the web service and the worker. Because the API and the database are both in Mumbai, a request that runs five queries does not pay five trips abroad. If part of your backend stays on Netlify Functions for a while, connect those functions through the pooled port when your database lists one; the connection pooling guide explains which endpoint to use when.

What a Mumbai backend costs

You can try the whole setup at Rs 0. The free Nano size has 512 MB of memory and 0.1 vCPU, and a free web service sleeps after 15 minutes without requests. The free tier also includes one managed Postgres with 1 GB of storage, subject to free capacity.

For production, paid web sizes start at Rs 298 a month plus GST for 1 GB and 1 vCPU, always on. Adding the DB Starter Postgres (Rs 299) brings an API with its database to Rs 597 per month before GST. You pay in rupees by UPI, Indian card or netbanking, and get a GST invoice. See Voroa pricing for every size.

Run your Netlify backend on Voroa

Keep the frontend on Netlify if you like it there. Move the API, the database and the workers to Voroa, where they run as normal processes in Mumbai, deploy from GitHub on every push when auto-deploy is on, and are billed in INR. See what a Voroa web service includes, or read the wider backend API hosting guide first.

FAQ

Is Netlify good for backend development?

It is good for small, request-shaped backend work: webhooks, form handlers, and short API routes. It is a weaker fit for long-running servers, queues and WebSockets, unless you use Netlify Server, which is still in Early Access.

Can I run Socket.IO on Netlify?

Not on ordinary Netlify Functions, because a function cannot keep a connection open. Netlify Server supports WebSockets, but an Express app exported as it is answers WebSocket requests with a 501; wrap it in http.createServer() and export the server, or start it with app.listen(process.env.PORT). Any host that runs a long-lived Node.js process also works.

Does Netlify have a server in India?

Netlify’s documented function regions do not include India; the closest are Singapore and Tokyo. Netlify Server lists only Ohio and Frankfurt.

Can I use Netlify for the frontend and another host for the API?

Yes. Set the API URL as a build-time environment variable on Netlify, and allow your Netlify domain in the API’s CORS settings.

Do I need to rewrite my Express app to leave Netlify Functions?

No. Remove the serverless-http wrapper, call app.listen(process.env.PORT), and your routes stay the same.

Netlify facts here come from Netlify’s own documentation and changelog, checked on 14 November 2026.

What is Netlify Drop?

Drop is Netlify’s drag-and-drop deploy page at app.netlify.com/drop. You drop a folder or a zip file of your site, Netlify uploads it, and you get a URL ending in netlify.app. You do not need a Git repository, and you do not need an account to start. If you are signed in, Netlify can also run your build for you.

It is old and popular. Netlify’s own history post traces it back to a drag-and-drop tool called BitBalloon, first committed in 2013, and says more than 60 percent of people who signed up in June 2026 made their first deploy this way.

How a drag-and-drop deploy works

1. Open the Drop page in your browser.
2. Drag your project folder, or a zip of it, onto the drop zone. The folder should have an index.html at its top level.
3. Wait for the upload. Netlify gives you a preview URL ending in netlify.app.
4. Sign up or log in to claim the site so it stays online.
5. To update it later, open the project’s dashboard and drop the new folder onto the area under Production deploys. The changes publish straight to production.

Signed in versus not signed in

What happens to your files depends on whether you are logged in.

• Not signed in. Netlify publishes the files exactly as they are. Drop a finished output folder, such as dist or build, not your source code. The URL is protected with a temporary password until you claim it.
• Signed in. You can drop a project that still needs building. Netlify detects the framework, installs dependencies and runs the build before it publishes. Dropping a pre-built folder still works.

Claiming a dropped site, and what happens if you do not

An unclaimed drop is temporary by design. Netlify’s history post says the claim window was cut from 24 hours to one hour in January 2022, anonymous sites were capped at three per IP address, and unclaimed sites were later suspended and then deleted. For anonymous deploys from its command-line tool, the documentation states the window plainly: you can claim the project within one hour. A reply on Netlify’s forum says one user’s anonymous drop “was automatically deleted because it was not claimed”.

So claim the site the moment it works. Two more things to know:

• Claimed does not always mean public. Teams created on or after 28 July 2026 make new projects private by default, drops included. On the free plan only the team owner can see a private project until you select Make public.
• An unclaimed drop can hold your domain. One forum thread from June 2026 describes a custom domain that could not be added to a new project because an old, unclaimed anonymous drop still had it. The user had to ask Netlify support to release it.

Where drag-and-drop deploys run out

Drop is excellent for a first deploy. It gets harder the second, tenth and fiftieth time.

Size. Netlify says uploads under 50 MB work best, and single files over 10 MB may get the deploy stuck. Your computer also needs free memory of roughly four times the uncompressed project size. For anything larger, Netlify points you to its command-line tool.

Every update is manual. You rebuild on your laptop, find the right folder and drag it again. Nothing records which version of your code is live or who changed it.

One wrong drop replaces a live site. Updates go straight to production. In a July 2026 forum post, a beginner developer at a family-run business described dragging a hobby project’s files “directly on top of my live” business site. Git gives you a commit and a review step before that can happen.

Each update is a production deploy. On Netlify’s credit-based free plan, every successful production deploy costs 15 of the month’s 300 credits, and there is no preview step on a drop. Our guide to Netlify free plan limits and credits shows how fast that adds up.

No collaboration. A teammate cannot propose a change. They send you files, and you drop them.

When to move from drag-and-drop to Git

Move when any of these is true:

• You update the site more than once or twice a month.
• More than one person edits it.
• It is a client or business site that must not break by accident.
• You want to see what changed, and put the last good version back quickly.
• You are tired of rebuilding locally before every update.

Netlify’s guide on how to deploy a site says the same: Git deploys are “the right choice for any project with a repo behind it”. If your site is a one-time event page or a quick demo, Drop is still fine.

Step 1: put the folder in a Git repository

If your project has never been in Git, these commands create a repository and push it to GitHub. Create an empty repository on GitHub first (GitHub explains how in creating a new repository), then run:

cd my-site
git init
git add .
git commit -m "First version of my site"
git branch -M main
git remote add origin https://github.com/your-name/my-site.git
git push -u origin main

The git init reference covers the options if you need them.

Step 2: connect the repository to your host

On Netlify you can do this from the dropped project itself: go to Project configuration, Developer settings, Continuous deployment, Repository, and choose Push to new repository. Netlify creates the repository on GitHub and pushes your files; that path supports GitHub only. After that, every push rebuilds and redeploys the site.

On any other host, you create a new site from the repository. How that works end to end, including what happens between git push and a live URL, is in our guide to push-to-deploy from GitHub.

How static sites deploy on Voroa

Voroa does not have a drag-and-drop or upload deploy. Every Voroa site deploys from a Git repository, which is the workflow this article recommends moving to anyway. Here is how a static site works:

1. Connect GitHub and pick the repository and branch.
2. Set the folder to serve: / for plain HTML at the top level, or a committed build folder such as /dist or /build.
3. Deploy. You get a live URL with HTTPS.
4. Turn on auto-deploy on every push, so each push to that branch publishes a new release.

One difference from a signed-in drop matters: a Voroa static site does not run a build. It serves the files in your repository as they are, just like a drop made without signing in. Commit your built output, or, if you want the build to run on every push, deploy the same repository as a web service, which installs dependencies and builds for you.

If your code is not on GitHub, Voroa can also build from any Git URL over https, public or private with an access token. Those services do not deploy on push by themselves; you deploy from the dashboard or call a deploy hook from your CI.

Static hosting on Voroa is free and needs no card. Single-page apps need one note: a static site serves only files that exist, so a visitor who refreshes on a route such as /dashboard gets a 404. Use hash routing, or deploy the app as a web service.

Publish your static site from GitHub

If you are moving off drag-and-drop, put the folder in a repository, connect it, and every push becomes a deploy you can roll back. See what Voroa static site hosting includes, or follow the step-by-step guide to deploy a static site from a repository.

FAQ

Is Netlify’s drag-and-drop deploy free?

Yes. It works on the free plan. Once the site is claimed, it counts towards the plan’s 300 monthly credits like any other site, and each update you drop is a production deploy.

Can I deploy a React or Vite app by dragging the folder?

If you are signed in, Netlify can detect the framework and build it. If you are not, drop the built output folder (dist or build), not the source folder.

Why does my dropped site ask for a password?

Anonymous drops are password-protected until you claim them by signing up or logging in.

Can I connect a custom domain to a dropped site?

Yes, after you claim it. If Netlify says another project is already using the domain, an old unclaimed deploy may still hold it, and you need to ask Netlify support to release it.

Does Voroa have a drag-and-drop deploy?

No. Voroa deploys from GitHub, or from any https Git URL. There is no upload page.

Every Netlify figure here comes from Netlify’s own pricing page and documentation, checked on 14 November 2026. Netlify changes plans often, so check your Usage & billing page before you rely on a number.

Netlify free plan limits in one table

Build minutes are not counted at all on the credit plans. A production deploy costs a flat 15 credits whether the build takes one minute or ten.

What 300 credits actually buy

The pool is shared, so the honest way to read it is: if you spent all 300 credits on one thing, how much of it would you get?

Nobody spends credits on only one thing, so the real numbers are lower on every line.

Deploys are the expensive part for a small site

For a low-traffic site, deploys usually cost more than traffic. Ten pushes to your production branch use 150 credits, which is half the month. If you push small fixes straight to production, you can run out before your visitors do. Pull requests are different: Deploy Previews and branch deploys cost nothing, so review changes on a preview and merge in batches.

Every file is a request

Netlify counts page views, asset requests, API calls and redirects as web requests. A page that loads its HTML, a stylesheet, a few scripts and a dozen images is around 20 requests, not one. That is still cheap (2 credits per 10,000), but a busy page with many small files grows the count faster than page views suggest.

Functions bill by memory and time

Functions, preview servers and the database feature all count as compute. A function runs with 1 GB of memory by default, so one hour of total run time across all calls is one GB-hour, which is 10 credits. Edge functions are counted as web requests instead.

A sample month

Here is a realistic month for a small portfolio or client site:

1. Ten production deploys: 150 credits.
2. 5 GB of images, scripts and pages sent to visitors: 100 credits.
3. That leaves 50 credits, or about 250,000 requests, for everything else.

A site with mostly text and compressed images fits. A site with large photos, a launch-day spike or a habit of deploying every small change does not.

Netlify Database and Netlify Server on the free plan

Netlify now sells two backend products, and both can be used on Free.

Netlify Database

Netlify Database is a managed Postgres database, generally available since 28 April 2026. According to its billing and limits page, the free plan allows:

The catch is the cost. Each compute unit costs 10 credits and database bandwidth costs 20 credits per GB, from the same 300-credit pool your site uses. The 48-unit monthly cap is worth 480 credits, more than the whole pool, so on Free you run out of credits before you reach the database’s own cap. A database that wakes often can pause your site.

Netlify Server

Netlify Server runs a long-lived Node.js backend, such as an existing Express, Hono, Fastify or Koa app. It entered Early Access on 10 November 2026. On Free you get one instance, it scales to zero after 5 minutes without requests, and it is free to use during Early Access; Netlify says it will be charged in credits once it is generally available. Full-stack frameworks such as Next.js, Astro and Nuxt do not run on it yet. Because its APIs may change, treat it as something to try, not something to put a client on.

What happens when the credits run out

On the free plan there is no overage bill and no way to buy more. Instead, Netlify pauses every project that belongs to the team, not only the one that used the credits. A paused project stops taking web requests, form submissions and other traffic, and all deploys stop too, including Deploy Previews. Visitors see a Site not available page.

You have two ways back: upgrade to a paid plan, or wait. At the start of the next billing cycle the credits reset and, according to Netlify’s documentation, the projects resume on their own.

When the pause does not lift on its own

Netlify’s community forum has many threads from August and September 2026 where free teams report staying paused after the reset, with 300 of 300 credits showing and the dashboard saying the team has exceeded its limit. Others describe a banner saying the team is “running on operational credits”, with production deploys paused while their live sites keep serving. We did not find official documentation of either state, and the error some posters quote tells them to contact support. If a client’s site depends on the free plan, plan for a few days of downtime, not a few hours.

The older free plan many accounts are still on

Accounts created before 4 September 2025 are on a legacy plan, and Netlify does not move them unless the owner chooses to. The legacy free plan works on separate meters:

This explains why articles disagree about “100 GB or 15 GB”. Both are right, for different accounts. If your old account fits comfortably in 100 GB, think before switching: Netlify’s billing FAQ says moving to a credit plan is permanent.

Can you use the free plan for client or commercial work?

We found no rule against commercial use on Netlify’s free plan in its pricing page, Terms of Use or Acceptable Use Policy. That is different from Vercel, whose Hobby plan is limited to non-commercial, personal use. Netlify’s Acceptable Use Policy does forbid using the platform for things unrelated to websites, such as general file storage or distribution, and allows suspension for abuse.

The real limit for client work is practical, not legal. The free plan has one seat, so you cannot add a client or a colleague as a member (free Reviewer roles can view and comment). New teams created since 28 July 2026 also start with projects private by default, so a new project stays private until you select Make public. And one busy client site can pause every other project on your team.

What this means if you build from India

Netlify prices are in US dollars, and its billing FAQ lists credit cards, Apple Pay and Google Pay as payment methods. It does not mention UPI or Indian tax invoices. That does not matter while you stay on Free, but it matters the day you upgrade: a dollar card charge, a bank’s foreign transaction markup, and no GST invoice your business can claim input credit on. Our post on Netlify pricing in rupees works through the paid plans.

If you are still choosing a free host for a project, our guide to free web app hosting in India compares the options by what they let you run, not only by price.

Where Voroa’s free tier is different

Voroa’s free tier is not bigger on every line, so here is the plain comparison, taken from what the Voroa free tier includes:

Two things are similar. Both stop free projects when a monthly limit runs out, and both bring them back at the next cycle without deleting anything. On Voroa, when a Free workspace has sent its 5 GB, its free services stop until 12 midnight IST on the 1st, and the owner gets an email listing what stopped.

The difference is what can take your site down. On Netlify, deploying often eats the same credits your traffic needs. On Voroa, a deploy is not charged on its own: builds count as build minutes. When a Free workspace uses its 500, new builds pause until the 1st, but sites that are already live keep serving. Static sites also do not use Voroa’s 750 free running hours, which are for free web services, workers and databases. When you upgrade, the bill is in rupees, paid by UPI or card, with a GST invoice; see usage and billing on Voroa.

If you need a quick one-off upload rather than a site you keep updating, read our note on Netlify Drop and when to move to Git deploys.

Host a free static site in Mumbai

Connect a GitHub repository, choose the folder to serve, and your site is live with HTTPS on Voroa’s free tier, no card needed. Start with static site hosting on Voroa, or follow the steps to deploy a static site from GitHub.

FAQ

How many sites can I host on the Netlify free plan?

Netlify’s pricing page does not list a project limit for Free. The limit that matters is the 300 credits, which every project on the team shares.

Do Deploy Previews use Netlify credits?

No. Deploy Previews and branch deploys cost 0 credits. Only successful production deploys cost 15 credits. Failed deploys and rollbacks are also free.

Does Netlify delete my site when the free credits run out?

No. The site is paused and shows “Site not available”. It comes back when the credits reset at the next billing cycle, or straight away if you upgrade.

Is my account on the legacy plan or the credit plan?

If you created it before 4 September 2025 and never switched, it is on the legacy plan with 100 GB of bandwidth and 300 build minutes. Your Usage & billing page shows which plan you have.

Can I use a custom domain on Netlify’s free plan?

Yes. Custom domains with SSL are included on Free, according to Netlify’s pricing page. Traffic to the custom domain spends the same credits.

This guide is for Indian developers and small teams who want to know what a Netlify plan really costs in rupees. It covers each plan, what a credit buys, what happens when credits run out, and the GST and card charges that sit on top of the dollar price. Then it works three monthly bills through to the amount on your card statement.

All Netlify figures are from Netlify’s own pricing page and credit-based billing documentation, checked on 14 November 2026. Netlify changed its credit rates in April 2026, so re-check before you budget.

Netlify pricing plans in 2026, in dollars and rupees

Rupee amounts use Rs 94.20 to the dollar, the RBI reference rate on 13 November 2026. They are before GST and card charges, which are covered further down.

Two things changed on 14 April 2026 that older articles still get wrong. Pro stopped charging $20 per team member, so a team of five now pays the same $20 as a team of one. And form submissions became free on every credit plan.

How Netlify credits work

A credit is Netlify’s unit of usage. Your plan gives you a fixed number at the start of each billing cycle, and every metered action takes some away. Your billing cycle starts on the day you created the team, not on the 1st of the month.

What each action costs in credits

The production deploy line is the one Indian freelancers notice first. Every push to your main branch that publishes the site costs 15 credits, however small the change. Twenty production deploys use the whole Free allowance before a single visitor arrives.

What a credit is worth in rupees

Netlify prices extra credits at $10 for 1,500 on Pro, which is about 0.67 US cents a credit. At that rate, and at Rs 94.20 to the dollar:

On Personal, extra credits cost $5 for 500, or 1 cent each, so the same gigabyte of bandwidth costs $0.20 (about Rs 18.84). Credits included in your plan are a little cheaper than bought ones: Pro’s 3,000 credits for $20 work out at the same 0.67 cents, and Personal’s 1,000 for $9 at 0.9 cents.

What 300 free credits actually cover

The Free plan is $0 with 300 credits a month and a hard limit: you cannot buy more. Here is how quickly a small site can use them:

• 20 production deploys, and nothing else, or
• 15 GB of bandwidth, and nothing else, or
• a realistic mix: 8 production deploys (120), 6 GB of bandwidth (120) and 300,000 requests (60).

That is enough for a portfolio you update once a week. It is not enough for a site that deploys daily or that gets shared widely. If the Free limit is what you are deciding on, our guide to Netlify free plan limits goes through it in detail.

What happens when your credits run out

When the balance reaches zero, Netlify pauses every project on the team, not just the one that used the credits. Visitors see a “Site not available” page, the projects stop taking requests and form submissions, and you cannot publish a production deploy. Netlify emails you as credit use climbs, including at 50%, 75% and 100%.

What you can do next depends on the plan:

1. Free: wait for the next billing cycle, or upgrade.
2. Personal or Pro, auto recharge off: buy a credit pack by hand, or wait.
3. Personal or Pro, auto recharge on: Netlify buys a pack for you each time the balance runs out and charges your saved card. Auto recharge is off by default and only the team owner can turn it on.

Bought credits do not expire, so a pack bought on the 28th is still there next month. Plan credits reset each cycle and are lost if unused, except on the larger Pro tiers.

This is a real change from Netlify’s old plans, which billed overage with no cap. In February 2024, a Starter-plan user reported a bill of about $104,000 after a traffic spike, which Netlify later said it would forgive. On a credit plan, the worst case is a paused site, not a five-figure invoice.

Pro credit tiers and paid add-ons

Pro starts at 3,000 credits for $20. A team owner can move to 5,000, 10,000, 15,000 or 20,000 credits a month for a single flat price. Tiers above 3,000 also carry unused credits forward for one extra billing cycle; the base tier does not. Netlify shows the price of each tier in the dashboard’s plan selector, which is the place to check it, because the public page renders it in the browser rather than printing it.

An upgrade takes effect immediately and resets your billing cycle. A downgrade waits for the end of the cycle, and any unused plan credits, rollover included, are removed when it happens.

Two add-ons are charged in dollars on top of the plan:

Netlify Database and Netlify Server: what they cost

Netlify now sells two backend products, and both draw from the same credit pool. Neither is offered on legacy plans.

Netlify Database is managed Postgres, generally available since 28 April 2026. It costs 10 credits per database compute unit per hour while the database is awake, and 20 credits per GB of data it sends out. Storage is free for now; Netlify says it will give notice before it starts charging for it. On Free and Personal, a database sleeps after 5 minutes idle, and only Pro and Enterprise can keep one always on. Free also caps each database at 48 compute units per cycle and 5 GB of stored data.

An always-on database at the minimum size runs about 720 hours a month, or around 7,200 credits. That is more than Pro’s base 3,000. On base Pro, the other 4,200 means three 1,500-credit packs: $30, or Rs 2,826 before tax, for the database’s compute alone.

Netlify Server runs a long-lived Node.js server such as Express, Fastify or Hono, WebSockets included. It entered Early Access on 10 November 2026 and is free while in Early Access. At general availability Netlify will charge credits for reserved memory (GB-hours) and active CPU time (vCPU-hours), but it has not published the rates. A server scales to zero after 5 minutes without requests, and scales up to 3 instances, or 1 on Free and Personal.

Legacy plans: Starter and the old $19 Pro

Teams created before 4 September 2025 can stay on a legacy plan. These use limits instead of credits:

Moving a team from a legacy plan to a credit plan is permanent. Netlify’s billing FAQ says you cannot go back, and functions lose their free allowance and are metered in GB-hours from the first second. Work out your credit use from last month’s usage before you switch.

What a Netlify bill costs on an Indian card

Netlify bills in US dollars and takes cards, Apple Pay and Google Pay. There is no UPI, no netbanking and no rupee price. Four things turn the dollar amount into what leaves your account.

GST. Netlify’s Self-Serve Subscription Agreement says its fees do not include taxes and that it may invoice them. We did not find a Netlify page that says whether it charges Indian GST, so look at your own invoice. If it adds 18% GST, that is part of the price. If you are a GST-registered business and the invoice has no GST, you usually pay 18% yourself under reverse charge and claim it back as input tax credit; our guide to reverse charge on foreign hosting bills explains the steps. Check your own case with your accountant.

The exchange rate. Your bank converts at its own rate on the day of the charge. We use the RBI reference rate of Rs 94.20 from 13 November 2026.

The card’s forex markup. Many standard Indian credit cards add 3.5% on foreign-currency spends, plus 18% GST on that fee, which is about 4.13% in total. Premium cards are often near 2% (2.36% with GST), and a few banks offer zero-markup cards. The worked bills below use 4.13%.

Recurring payments and declined cards. Under the RBI’s Digital Payments - E-mandate Framework, 2026, an automatic card payment above Rs 15,000 needs your approval each time. Indian users have also reported on Netlify’s community forum, from 2021 to 2025, that recurring charges on Indian cards were declined, and a Netlify support reply in December 2024 said it was “unable to collect payment from any Netlify customers in India”. Netlify’s terms allow it to suspend service when a payment fails, so do not rely on auto recharge from an Indian card without testing it first.

Three Netlify bills worked out in rupees

The usage below is an assumption for illustration. Your real numbers are on the Usage & billing page of your Netlify team.

Bill 1: a freelancer on Personal. 30 production deploys (450 credits), 20 GB of bandwidth (400) and 1 million requests (200) come to 1,050 credits, 50 over the allowance. With auto recharge on, Netlify buys one 500-credit pack. Total: $9 + $5 = $14. The 450 unused pack credits stay for next month.

Bill 2: a three-person team on Pro. 60 production deploys (900), 60 GB of bandwidth (1,200), 3 million requests (600) and 20 GB-hours of functions (200) come to 2,900 credits, inside the 3,000. Total: $20. Before April 2026, the seat charge alone would have made it $60.

Bill 3: a growing product on base Pro. 150 production deploys (2,250), 250 GB of bandwidth (5,000), 10 million requests (2,000) and 100 GB-hours of functions (1,000) come to 10,250 credits. After the 3,000 included, auto recharge buys five 1,500-credit packs to cover the other 7,250. Total: $20 + $50 = $70. The 250 unused pack credits carry over to the next month.

If your invoice carries no Indian GST and you are not registered, leave out the GST column: the $20 Pro bill then comes to about Rs 1,962.

Bill 3 is where the dollar model hurts most. Bandwidth alone is 5,000 of its 10,250 credits, because each gigabyte costs 20 credits whether your visitors are in Pune or Paris.

How Voroa’s rupee pricing compares

Voroa is a hosting platform that runs in Mumbai and bills in rupees, with a GST invoice for every payment and payment by UPI, Indian card or netbanking. There is no dollar conversion and no forex markup. For the same kinds of project, the pieces work differently:

• Static sites are free to host and are not charged per deploy. Voroa serves the files in your repository as they are and runs no build, so you commit your built dist or build folder. If you want the build run on every push, deploy the same repository as a web service instead.
• Bandwidth is pooled per workspace. The Free plan includes 5 GB a month; Growth (Rs 499 per month plus GST) includes 25 GB; Scale (Rs 1,499 per month plus GST) includes 1,024 GB. Extra bandwidth on a paid plan is Rs 8 per GB plus GST, billed after the month ends, and only up to the plan’s billing ceiling: on Growth, nothing above 100 GB a month is charged (on Scale, 10,240 GB). A Free workspace that uses its 5 GB is stopped until the 1st, much like a Netlify pause; paid plans are never stopped for bandwidth.
• Server code runs as an always-on service at a fixed monthly price, not on credits. The smallest always-on size is Rs 298 a month plus GST.

Take Bill 3’s traffic: 250 GB of bandwidth on Growth is billed only up to the 100 GB ceiling, so it is Rs 499 plus 75 extra GB at Rs 8, which is Rs 1,099, or about Rs 1,297 with GST. On Scale, the 1,024 GB allowance covers it, and Scale plus one Starter service for an API is Rs 1,797, or about Rs 2,120 with GST.

That is not a like-for-like swap, and the differences matter. Netlify serves your site from a global CDN and builds it for you; Voroa serves from Mumbai, which suits an Indian audience but is farther from visitors elsewhere. A Voroa static site does not send unknown paths to index.html, so a single-page app needs hash routing or a web service. Netlify Forms, Edge Functions and its AI features have no direct equivalent. See the static site hosting page for what is included and Voroa’s full price list for every plan. If you are weighing a move, read when a Netlify alternative makes sense first.

Netlify pricing FAQ

Can I buy more credits on the Netlify Free plan?

No. Credit packs and auto recharge are only for Personal and Pro. On Free, the 300 credits are a hard limit: once they are spent, every site on the team pauses until the next cycle unless you upgrade.

Is Netlify Pro $20 per user?

No, not any more. Since 14 April 2026 the credit-based Pro plan is $20 a month for the whole team with unlimited members. Legacy Pro teams created before September 2025 still pay $19 per member.

Does Netlify charge GST in India?

Netlify’s agreement says its prices exclude taxes and that it may invoice them, but it publishes nothing India-specific. If your invoice has no GST and you are registered, you usually pay it under reverse charge. A GST invoice for cloud hosting shows what a valid Indian invoice must contain.

Can I pay Netlify with UPI?

No. Netlify accepts credit cards, Apple Pay and Google Pay on self-serve plans, and ACH or wire transfer on Enterprise. Use a card that is enabled for international and recurring payments.

Why was my Netlify site paused?

Your team’s credit balance reached zero. Check the usage page for the meter that grew - usually bandwidth or production deploys - then buy a pack, turn on auto recharge, move to a higher tier, or wait for the cycle to reset.

Host a static site in rupees

You can put a static site on Voroa for free, in Mumbai, and pay in rupees only when you add paid services. Deploy a static site from GitHub in a few minutes, and keep the guide to outbound bandwidth handy so you know what counts.

Last checked: 14 November 2026, against Netlify’s pricing page, credit-based billing documentation, legacy plan documentation and Self-Serve Subscription Agreement. Comparing dollar hosts? The same working for Vercel is in our Vercel pricing guide for India.

Netlify vs Vercel in One Paragraph

Pick Vercel if your app is Next.js with server rendering, you want functions in Mumbai, or a function must run longer than a minute. Pick Netlify if you need a free plan with no rule against commercial work, a team of several people on one flat fee, or Postgres built into the platform.

Both have only just started to run long-lived processes, and both still do it in early form: Netlify Server is in Early Access and Vercel Daemons are in beta. If an always-on backend is your main need, see the last section.

Next.js on Each Platform

Vercel builds Next.js. The Next.js deployment docs list Vercel as a verified adapter, which means it runs the full Next.js test suite before major releases.

Netlify runs Next.js through its own OpenNext adapter, with zero configuration, for Next.js 13.5 and later. Its docs mark the App Router, ISR and image optimisation as full support, and middleware runs as Netlify Edge Functions. They also list four gaps:

• Pages that use the edge runtime for server rendering run on Node.js in your functions region, not at the edge.
• Headers and redirects are applied after middleware, which differs from a standalone Next.js server.
• Node.js middleware cannot use C++ addons or the filesystem.
• Rewrites in the Next.js config cannot point to static files in the public folder.

The Next.js docs say Netlify is working on a verified adapter, and until then its integration is “not verified by the Next.js team”. For a static Next.js export, a Vite app or Astro, both platforms are equally at home.

Functions and Edge Code: Limits That Decide Real Apps

This is where the two differ most for backend work.

Netlify’s scheduled functions stop at 30 seconds.

If an API calls a slow payment gateway or generates a PDF, the 60-second cap on Netlify is the one to check first.

Can Your Code Run in India?

Static files are served from each platform’s CDN. Your server code is a different story.

• Vercel lists Mumbai (bom1) among 19 compute regions. Its regions page says functions default to Washington, D.C. (iad1), so change the function region to Mumbai yourself. Mumbai rates are slightly higher: $0.14 per hour of Active CPU and $0.20 per GB of data transfer on Pro.
• Netlify lists 12 self-serve regions in its function configuration docs. None is in India; the nearest are Singapore and Tokyo. Functions default to Ohio, and changing the region needs a Pro or Enterprise plan. Netlify Server, its new long-running option, offers only Ohio and Frankfurt.

If your database sits in India, a Vercel function in Mumbai saves a round trip abroad on every query. A Netlify function in Singapore cannot avoid it.

Builds and Deploy Limits

Netlify’s 15-minute figure comes from its support guide, not its docs. On new credit-based plans, Netlify no longer counts build minutes. It charges 15 credits per successful production deploy, and deploy previews cost nothing.

Free Plan Rules: Commercial Use and Running Out

This is the clearest difference.

Vercel Hobby is free, but Vercel’s terms say you “shall only use the Services under a Hobby plan for your personal or non-commercial use.” It includes 100 GB of data transfer, 1,000,000 function invocations and 4 hours of Active CPU a month. Go over and you wait until 30 days have passed. You cannot buy more on Hobby, and Hobby cannot deploy a private repository owned by a GitHub organisation.

Netlify Free has no such rule. Netlify’s 2024 Free plan announcement said you can “deploy commercial projects”, and nothing on the current pricing page restricts it. Vercel’s own comparison page lists free commercial use as a Netlify strength. Free gives 300 credits a month with a hard limit. When they run out, Netlify’s docs say every project is paused and visitors see a “Site not available” page until the cycle resets. Each production deploy costs 15 credits and each GB of bandwidth costs 20, so 20 production deploys use the whole month on their own.

Accounts created before 4 September 2025 stay on Netlify’s legacy plans unless they switch: 100 GB of bandwidth and 300 build minutes on Free. Our Netlify free plan limits guide works through the credit maths.

Paid Plans in Rupees

Both price in US dollars. The rupee figures below are list prices only: plan fee converted at Rs 94.20 to the dollar (the RBI reference rate on 13 November 2026), before any usage over the allowance, 18% GST and your card’s forex markup. GST and a typical 4.13% card markup alone add about 23%.

Netlify Pro includes unlimited team members. Vercel charges each developer seat; viewer seats are free. For a small agency in Pune or Bengaluru, that seat price is often the deciding line. Our Netlify pricing guide for India and Vercel pricing in rupees work full bills through, with usage, GST and card charges added. That is why a Netlify Pro bill of $20 lands at about Rs 2,315 on an Indian card there.

Billing, GST and Invoices From India

Vercel’s tax page says prices exclude GST and that it began collecting VAT, GST or equivalent from international customers on 1 April 2026, where it is registered to collect. Its tax-ID guidance names EU and UK VAT numbers. It does not mention a GSTIN or rupee invoices.

Netlify’s pricing page shows dollars. Its Self-Serve Subscription Agreement says fees exclude taxes and that Netlify may invoice them, but we could not find an official Netlify page on Indian GST.

For a GST-registered business, a dollar invoice without GST usually means paying 18% yourself under reverse charge. Our guide to reverse charge on foreign hosting explains the steps.

Databases and Storage

Netlify Database is a managed Postgres built into Netlify, generally available since April 2026 on credit-based plans. Each deploy preview gets its own database branch. It uses credits for compute and bandwidth; storage is free for now. Netlify’s docs we read do not say which region the database runs in.

Vercel’s first-party storage on Hobby and Pro is Blob. For Postgres or Redis, its pricing page points to Marketplace Integrations.

Netlify vs Vercel at a Glance

When You Need Neither

Most code on both platforms runs as functions that start on a request and stop. That fits a frontend with a few API routes. A backend that must stay up is a harder fit:

• an Express or Django API holding database connections open,
• a queue worker that runs all day,
• a Socket.IO server, or
• Postgres that must sit next to the API in India.

Both have begun to close this gap. Netlify Server, in Early Access since November 2026, runs any Node.js server such as Express, Fastify or Hono, and holds WebSocket connections open. It is free during Early Access and will be charged in credits later. Each instance stops after 5 minutes without requests, a server scales to 1 instance on Free and Personal plans (3 on others), full-stack frameworks such as Next.js do not run on it yet, and its regions are Ohio and Frankfurt.

Vercel Daemons, in beta on all plans, run containerised background processes that pull their own work and do not receive traffic. On Hobby they stop at 5 Active CPU-hours or 420 GB-hours of memory in a month.

So you can now run a server on either, but not one that stays up in India. A common split is to keep the frontend on Netlify or Vercel and run the API, workers and database somewhere built for processes, near your users and your data.

Run the Backend on Voroa, in Mumbai

Voroa runs your API as a long-running web service in Mumbai, next to a managed PostgreSQL database in India. A Next.js app runs with next build and next start, the Node.js server mode the Next.js docs say supports every feature; the Next.js deploy guide has the settings. Pull requests can get their own preview environments.

The free Nano size is Rs 0 with 512 MB and 0.1 vCPU shared, and free web services sleep after 15 minutes without requests; see what the free tier includes. Paid web sizes start at Rs 298 a month plus GST, billed in rupees with a GST invoice, and you can pay by UPI. Compare sizes on the Voroa pricing page.

FAQ

Is Netlify or Vercel better for a Next.js app?

Vercel, for most server-rendered Next.js apps. Next.js lists it as a verified adapter, and its functions can run in Mumbai. Netlify works well for Next.js 13.5 and later, with the few gaps its docs list.

Can I use Vercel’s free plan for a client project?

No. Vercel’s terms limit Hobby to personal or non-commercial use. Netlify’s Free plan has no such restriction: its 2024 launch post said commercial projects are fine, and the current pricing page does not limit them. It is capped at 300 credits a month.

Does Netlify have servers in India?

Netlify’s documented function regions do not include India. The nearest are Singapore and Tokyo, and choosing a region needs a Pro or Enterprise plan. Netlify Server runs only in Ohio or Frankfurt.

Do Netlify and Vercel charge GST to Indian customers?

Vercel says it collects GST or equivalent from international customers since 1 April 2026, where it is registered. Netlify’s public pages do not say. Both bill in US dollars.

This guide covers those basics, then what we saw when we tested restarts, overlap and two processes. One common setting quietly throws away every missed run.

On this page

• A cron job in five lines
• Schedulers, triggers and job stores
• Test 1: two processes, every job twice
• Test 2: overlap is blocked by default
• Test 3: what a restart does to missed runs
• APScheduler, schedule or system cron?
• FAQ

A cron job in five lines

pip install "apscheduler<4"

from apscheduler.schedulers.blocking import BlockingScheduler

sched = BlockingScheduler(timezone="Asia/Kolkata")

@sched.scheduled_job("cron", hour=9, minute=0)
def daily_digest():
    send_digest()          # your code

sched.start()

That runs daily_digest at 9:00 am India time every day. Version 3.11 is the current stable release. Version 4 is still in alpha with a different API, so pin <4 for now.

Schedulers, triggers and job stores

The library has three parts you choose between:

A cron trigger takes the same fields as a cron line, by name: minute="*/5" for every five minutes, day_of_week="mon-fri", hour=9 for weekday mornings. Or build one from a crontab string with CronTrigger.from_crontab("0 9 * * 1-5").

Test 1: two processes, every job twice

Setup for all tests: version 3.11.3 on Python 3.14, a cron trigger firing every second so results appear quickly, and Redis 8.10.3 to count runs. Measured 7 November 2026 on a laptop.

A web app usually runs as several worker processes. Gunicorn with four workers loads your app four times (without --preload). If the scheduler starts at import time, there are now four schedulers.

Every job ran twice. With four Gunicorn workers it would run four times. Two fixes work:

• Run the scheduler in one dedicated process, not inside every web worker.
• Or take a lock before the work, for example a Redis key set with NX, so only one process wins each run.

Test 2: overlap is blocked by default

A job that takes 2.5 seconds, scheduled every second. This is where it differs from many libraries.

By default, the scheduler will not start a job while the previous run is still going. It skips that run and logs a warning that the maximum number of running instances was reached.

That is usually the safe choice. Raise max_instances only if the job is safe to run in parallel.

Test 3: what a restart does to missed runs

We stopped the scheduler for about 5 seconds, as a deploy would, and started it again. Then we tried the settings people usually recommend.

The memory store forgets everything on restart, which most people expect.

The second row is the trap. A persistent store is meant to remember missed runs. But the common pattern add_job(..., id="x", replace_existing=True) at start-up overwrites the stored job with a fresh one, so its missed runs are thrown away. It looked identical to the memory store.

Missed runs only came back when the code left the stored job alone:

import time
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore

sched = BackgroundScheduler(
    jobstores={"default": SQLAlchemyJobStore(url="sqlite:///jobs.sqlite")},
    timezone="Asia/Kolkata",
)
sched.start(paused=True)                 # load stored jobs without running them yet
if sched.get_job("digest") is None:      # first start only
    sched.add_job(daily_digest, "cron", hour=9, id="digest",
                  misfire_grace_time=3600, coalesce=True)
sched.resume()                           # a stored job keeps its missed runs
while True:
    time.sleep(60)                       # keep the process alive

We ran this pattern through three restarts in a row: no error, and the stored job carried on each time. The paused start needs BackgroundScheduler; with BlockingScheduler, start() never returns.

Then choose what a catch-up means. With coalesce=False, every missed run fires at once on restart; we saw a burst of 7.

With coalesce=True, the documentation says they collapse into one run, which is right for most reports and syncs. On a job firing every second our test could not tell that merged run apart from a normal one, but there was no burst. misfire_grace_time sets how late a run may be and still count.

Timing: runs fired a median of 8 to 15 ms after the scheduled second with the memory store, and 33 to 50 ms with the SQLite store.

APScheduler, schedule or system cron?

For queued work rather than timed work, a job queue fits better. Our Celery and Redis guide covers the Python option, including Celery beat for periodic tasks.

Run Python scheduled jobs on Voroa

Two ways, depending on your code. If your job is a script that runs and ends, create a Cron Job from your repository with a command such as python digest.py and a schedule. Schedules run in India Standard Time.

If the scheduler lives inside a long-running process, deploy that process as a background worker, a single instance kept running, so the scheduler is never duplicated by web traffic.

Either way, keep jobs safe to run twice. Setup is in scheduling a task on Voroa and worker or cron job. The Node.js version of these tests found the same duplicate-run problem.

FAQ

What is it used for? Running Python functions on a schedule inside your app: at set times (cron), at fixed intervals, or once at a given moment.

Why does my scheduled job run twice? The scheduler started in more than one process, often one per Gunicorn or Uvicorn worker. Run it in a single process or use a lock.

Does it run missed jobs after a restart? Only with a persistent job store, and only if you do not replace the stored job at start-up. In our test, replace_existing=True threw the missed runs away.

What does coalesce do? With coalesce=True, several missed runs of the same job collapse into one when the scheduler catches up. With False, each missed run fires separately.

How do I stop overlapping runs? You usually do not need to: max_instances defaults to 1, so it skips a run while the last one is still going.

Should I use version 4? Not yet for production. It is still an alpha with a different API; 3.11 is the stable line.

Tested 7 November 2026 with version 3.11.3 on Python 3.14. Found something out of date? Write to support@getvoroa.com.

This guide explains how that works, when it is worth it, and the one rule most teams learn the hard way: a job can run more than once. We measured both the speed-up and the double run with a real queue.

On this page

• Why move work out of the request?
• The three parts: producer, queue, worker
• Triggered jobs and scheduled jobs
• A crashed worker means a second run
• Rules for jobs that survive production
• Choosing a job queue
• FAQ

Why move work out of the request?

Users wait for every millisecond of a web request. If signing up sends a welcome email through a provider that takes 2 seconds, the sign-up page takes 2 seconds too. If the provider is down, sign-up fails.

Put the email on a queue instead and the request only waits for the enqueue. With BullMQ 6.7 on a local Redis, adding a job took 0.65 ms at the median and 1.44 ms at the 99th percentile, over 200 jobs. Over a network, add one round trip.

Use a background job when the work is slow, can fail and be retried, or the user does not need the result in the same response.

The three parts: producer, queue, worker

• Producer: your web app. It adds a job with the data needed, such as a user ID, not the whole user.
• Queue: where jobs wait. Usually Redis or a Postgres table, so jobs survive a restart of your app.
• Worker: a separate process that takes jobs one by one, runs them, and marks each done or failed.

The worker is a long-running program with no web address. It is deployed separately from the web app, so a slow job never blocks a page, and you can run more workers when the queue grows.

Triggered jobs and scheduled jobs

Jobs start in two ways:

Triggered jobs need a queue and a worker. Scheduled jobs can be a plain cron job that starts, works and exits; our guide to what a cron job is covers that side. Many queues also accept delayed and repeating jobs, so one worker can handle both.

A crashed worker means a second run

We started a job that takes 10 seconds, then killed the worker process 3 seconds in, the way an out-of-memory kill or a deploy would, and started a second worker right after the kill.

BullMQ noticed the dead worker’s lock had expired and handed the job out again, about a minute later with default settings. That is the right behaviour, because the work was never finished. But the first 3 seconds of the job had already happened.

If those 3 seconds sent an email or charged a card, the customer now gets it twice. Every queue that retries works this way. It is called at-least-once delivery, and it is why the first rule below matters.

Rules for jobs that survive production

1. Make jobs idempotent. Running a job twice must do no extra harm. Record that the email was sent, or use a unique key with your payment provider, and check it before acting.

2. Pass IDs, not objects. Put userId: 42 in the job, and load fresh data when the job runs. The user may have changed their email since the job was queued.

3. Retry with backoff, then stop. Retry a failed job a few times with growing delays, then move it to a failed list a person can look at. Retrying forever hides the problem.

4. Keep jobs short. One long job holds a worker and is the most likely to be cut off by a deploy. Split a big import into many small jobs.

5. Watch the queue length. A queue that keeps growing means workers cannot keep up. That is your signal to add workers or speed the job up.

Choosing a job queue

Redis-backed queues are the most common and fast; Redis lists are the classic building block. A Postgres queue means one less service: workers take jobs with FOR UPDATE SKIP LOCKED, described in the PostgreSQL SELECT documentation, so two workers never take the same row.

We tested the two most common in depth: BullMQ with Redis and Celery with Redis, including how many Redis commands an idle worker sends.

Running background jobs on Voroa

On Voroa, a worker is a Background Worker: built from your GitHub repository, with no web address, restarted if it exits. Run your web app as a web service, the worker beside it, and a managed Redis or Postgres database as the queue, all in Mumbai.

A program that finishes and exits belongs in a Cron Job instead, or Voroa will keep restarting it. The guide worker or cron job helps you pick, and deploying a background worker has the steps. Plans and sizes are on the background workers page.

FAQ

What is a background job? Work your app does outside the web request, in a separate process, such as sending email or generating a report. The user gets a response without waiting for it.

What is the difference between a background job and a cron job? A background job is usually triggered by an event and picked up by a worker. A cron job is started by the clock. Many apps use both.

Can a background job run twice? Yes. If a worker crashes mid-job, the queue hands the job out again. In our test the second run started about a minute after the crash. Make jobs safe to repeat.

Do I need Redis for background jobs? No. Redis is the most common queue, but a Postgres table with SKIP LOCKED works well at small and medium scale.

How many workers do I need? Start with one. Add more when the queue length keeps growing or jobs wait too long to start.

Measured with BullMQ 6.7.1 on a local Redis on 7 November 2026. Found something out of date? Write to support@getvoroa.com.

On this page

• When a Node.js app needs a job queue
• A working queue in two files
• What each job costs in Redis, measured
• The idle worker that is never idle
• Finished jobs fill your memory
• Concurrency: how many jobs at once
• Choosing a Redis for your queue
• Production checklist
• Bull, RabbitMQ or something else?
• FAQ

When a Node.js app needs a job queue

A web request should answer in well under a second. Some work takes longer than that or can fail and need a retry: sending an email through a provider, generating a PDF invoice, resizing an upload, calling a payment or AI API, or sending a webhook to a customer. Doing that inside the request makes the user wait and loses the work if the server restarts.

A queue splits it in two. The web server adds a small job record to Redis and answers at once. A worker process takes jobs off the queue, runs them, retries failures with a delay, and records the result. If the worker restarts, unfinished jobs are still in Redis.

A working queue in two files

Install the package (it brings its own Redis client, ioredis):

npm install bullmq

The shared setup, one file both processes import:

// queue.js
import { Queue, Worker } from 'bullmq';
import IORedis from 'ioredis';

// Web side: fail fast if Redis is down, so a request never hangs waiting for it.
// Trade-off: an add() before the first connect completes throws instead of waiting.
const queueConnection = new IORedis(process.env.REDIS_URL, { enableOfflineQueue: false });
export const emailQueue = new Queue('email', { connection: queueConnection });

// Worker side: keep retrying through a Redis restart instead of crashing
export const workerConnection = () =>
  new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null });
export { Worker };

The producer, inside a route handler in your web app. It adds a job and returns:

import { emailQueue } from './queue.js';

await emailQueue.add('welcome', { userId: 42 }, {
  attempts: 5,
  backoff: { type: 'exponential', delay: 2000 },
  removeOnComplete: { count: 1000 },
  removeOnFail: { age: 7 * 24 * 3600 },
});

The worker, a separate long-running process:

// worker.js
import { Worker, workerConnection } from './queue.js';

const worker = new Worker('email', async (job) => {
  await sendWelcomeEmail(job.data.userId);   // your code
}, { connection: workerConnection(), concurrency: 10 });

worker.on('failed', (job, err) => console.error(job?.id, err.message));

process.on('SIGTERM', async () => { await worker.close(); process.exit(0); });

That is the whole pattern. The options in the producer are the ones that matter in production, and the sections below explain why.

What each job costs in Redis, measured

We ran version 6.7.1 of the library from Node.js 24 on a Windows laptop against Redis 8.10.3 in a Linux virtual machine (WSL2) on the same laptop, and counted every command the server executed, using Redis’s own command statistics and MONITOR. Measured 7 November 2026.

Two round trips per job is efficient: the library does its bookkeeping inside Lua scripts on the server, so a job costs your app very little network time.

The 32 is what matters if your Redis host charges per command. Upstash, for example, bills a script as one command plus one for every Redis call the script makes. At about 32 commands per job, the 500,000 commands in Upstash’s free tier cover roughly 15,600 jobs a month, before counting the idle cost below.

The idle worker that is never idle

A worker with nothing to do still talks to Redis. It waits for new jobs with a blocking command that times out every few seconds, and it checks for stalled jobs on a timer.

We started one worker on an empty queue and counted for two minutes:

So one idle worker uses nearly ten times a 500,000-command free allowance every month, without processing a single job. Two workers, double it. This is not a bug; it is how a responsive queue works. It is the reason Upstash’s own documentation recommends a fixed-price plan for worker-heavy setups, and the reason we said in our free Redis hosting comparison that a command-metered tier is the wrong fit for a queue.

The fix is to choose Redis that limits memory, not commands.

Finished jobs fill your memory

By default the library keeps every completed job in Redis, forever. We measured what that costs:

469 bytes sounds small. At 10,000 jobs a day it is about 140 MB a month, which is more than a 128 MB store holds. Your queue then stops accepting jobs, or, worse, if the store is set to evict keys, it starts deleting queue data.

Keep a bounded history instead. removeOnComplete: { count: 1000 } keeps the last thousand for your dashboard, and removeOnFail: { age: 604800 } keeps failures for a week so you can inspect and retry them.

Concurrency: how many jobs at once

concurrency is the number of jobs one worker runs at the same time. We timed 10,000 jobs that did no work, with Redis in a virtual machine on the same laptop, so this measures the queue itself:

Going from 1 to 10 tripled throughput. It then levelled off at about 5,850 a second, because with jobs that do no work, Redis, the library’s scripts and the client become the limit, not the worker. Real jobs spend most of their time waiting on an email provider or an API, so for I/O-bound work a concurrency of 10 to 50 per worker is normal. For CPU-heavy work such as image processing, keep concurrency near the number of CPU cores and add worker processes instead.

Distance changes these numbers. With concurrency 1, each job needs at least one round trip to Redis. From a server in Mumbai we measured about 9 ms to a Mumbai region and about 86 ms to Singapore, so a single-concurrency worker talking to a Singapore store tops out at roughly a dozen jobs a second, however fast your code is. That is an estimate from the round trip, not a measured queue run, but the direction is certain: keep the worker and the store in the same region.

Choosing a Redis for your queue

A queue has stricter needs than a cache:

1. No eviction. The library cannot work if Redis deletes keys to free memory. The eviction policy must be noeviction, so a full store refuses writes rather than silently dropping jobs. See the Redis eviction policies for what each one does.
2. Data kept on disk. A store that empties on restart loses every queued job. Use one with persistence.
3. Memory, not commands, as the limit. As measured above, idle workers alone send millions of commands a month.
4. Enough connections. Each Queue and Worker holds its own connection, and a worker uses an extra one for its blocking wait. Two web instances and two workers need about 6, more if you add event listeners or a dashboard.
5. The same region as the worker. Every job pays round trips to Redis.

Valkey and Redis should both work for this, since the queue uses core commands and Lua scripts; test with your own jobs before you rely on Valkey. Our Valkey vs Redis comparison covers the differences that do exist.

On Voroa, a key value store’s When memory is full setting defaults to Keep everything, which is the no-eviction behaviour a queue needs. The store keeps data on disk with a nightly snapshot, runs in Mumbai next to your services, and is limited by memory rather than commands. Details are in the Key Value guide.

Production checklist

• Use separate connections for producers and workers. The library’s own production guide asks for maxRetriesPerRequest: null on workers, so they retry through a Redis restart, and for producers that fail fast, so a web request does not hang while Redis is down. The setup file above does both.
• Bound job history with removeOnComplete and removeOnFail, as above.
• Retry with backoff. attempts: 5 with exponential backoff absorbs a provider that is briefly down.
• Shut down gracefully. Call worker.close() on SIGTERM so a deploy lets running jobs finish rather than leaving them stalled.
• Keep payloads small. Put an ID in the job and load the record in the worker. Never put passwords or card data in a job.
• Make jobs idempotent. A job can run twice after a crash or a stall. Sending the same email twice is annoying; charging a card twice is worse. Check before you act.
• Run the worker as its own process. Deploy it separately from the web server, so a burst of jobs never slows your pages. On Voroa that is a background worker, which never sleeps; the steps are in deploying a background worker.
• Put REDIS_URL in an environment variable, never in code. See environment variables on Voroa.

Bull, RabbitMQ or something else?

Bull is the older library by the same authors. It is in maintenance mode; start new projects on the newer one.

RabbitMQ is a dedicated message broker. It is the better choice when many different services in different languages exchange messages, or when you need complex routing. For one Node.js app that needs background jobs with retries, delays and a dashboard, a Redis queue is simpler: you probably already run Redis, and there is one less server to look after.

Cron is for work that runs on a clock, such as a nightly report. A queue is for work triggered by events. Many apps use both; a scheduled task can add jobs to the queue.

Host the queue and the worker together

Voroa runs your web service, your background worker and a Redis-compatible key value store side by side in Mumbai, with no eviction by default and a free store size to start. See the sizes on the managed Redis page.

FAQ

Does the worker need its own server? It needs its own process. It can share a machine in development, but in production run it as a separate service so it can restart and scale on its own.

Can I use it with a free Redis tier? Yes, if the tier limits memory rather than commands, keeps data on disk and does not evict. A command-metered free tier is used up by one idle worker in a few days.

Why are my jobs stuck in “waiting”? Usually no worker is running, the worker is connected to a different Redis or queue name, or the worker crashed on start. Check the worker’s logs first.

Why did Redis run out of memory? Completed jobs are kept by default. Set removeOnComplete and removeOnFail with a count or an age.

Does it work with Valkey? It relies on core commands and Lua scripts, which Valkey supports. Test with your own jobs before you switch.

Is it free? The library is open source under the MIT licence. Its authors also sell a Pro version with extra features such as groups and batches.

Measured 7 November 2026 with library version 6.7.1 and Redis 8.10.3 in WSL2 on a laptop. Found something out of date? Write to support@getvoroa.com.

This guide answers what beat is and how it differs from a worker, shows the setup, then what we saw when we tested the two mistakes that cause most beat problems: running more than one beat, and restarting it.

On this page

• What is Celery beat?
• Celery beat vs Celery worker
• How beat fits with workers
• Set up a periodic task
• Test 1: two beats, every task twice
• Test 2: what a restart does
• Timezones
• Storing the schedule in Django’s database
• Running beat in production
• FAQ

What is Celery beat?

Celery beat is Celery’s built-in scheduler for periodic tasks. It runs as its own process, reads a schedule of intervals or crontab() times, and when a task is due it sends a message to the broker. A Celery worker then picks the message up and runs the task. You run exactly one beat per schedule.

Celery beat vs Celery worker

Periodic tasks need both. Beat decides when; the worker does the work.

The Celery docs say it directly: “You have to ensure only a single scheduler is running for a schedule at a time, otherwise you’d end up with duplicate tasks.” Workers have no such limit.

How beat fits with workers

A Celery setup with periodic tasks has three parts:

• Beat decides when a task is due and sends a message to the broker.
• The broker, usually Redis or RabbitMQ, holds the message.
• Workers take messages off the broker and run the tasks.

You can run many workers. You should run exactly one beat, for reasons the first test makes clear.

Set up a periodic task

# tasks.py
import os
from celery import Celery
from celery.schedules import crontab

app = Celery("tasks", broker=os.environ["REDIS_URL"])
app.conf.timezone = "Asia/Kolkata"

app.conf.beat_schedule = {
    "daily-digest": {
        "task": "tasks.send_digest",
        "schedule": crontab(hour=9, minute=0),          # 9:00 am IST
    },
    "cleanup-every-15-min": {
        "task": "tasks.cleanup",
        "schedule": crontab(minute="*/15"),
    },
}

@app.task
def send_digest(): ...

@app.task
def cleanup(): ...

Run the worker and beat as two separate processes:

celery -A tasks worker --loglevel=info
celery -A tasks beat --loglevel=info

A schedule can be a crontab(...) for calendar times or a number of seconds for a fixed interval, such as 300.0 for every five minutes.

Test 1: two beats, every task twice

Setup for both tests: Celery 5.7.0 on Python 3.14 with Redis 8.10.3 as the broker. One worker process, and a task scheduled every 2 seconds that records each run. Measured 7 November 2026 on a laptop.

Two beats sent every task twice, and the worker ran both copies. Beat does not know another beat exists.

This happens more easily than it sounds. Deploy beat inside a web service that runs two instances, or start a worker with -B (which embeds beat) on two machines, and you have two beats.

Test 2: what a restart does

We stopped the only beat for 10 seconds and started it again with the same schedule file.

Beat did not replay the runs it missed. A run came 0.6 seconds after start-up, then the normal schedule carried on. With a 2-second schedule, we cannot tell whether that first run was a catch-up or simply the next tick.

For a job every few minutes, that is usually fine.

For a daily job it depends on the schedule file, where beat keeps last-run times.

If the file is lost, for example on a host that wipes files on each deploy, a beat that is down at 9:00 am skips the whole day. If a daily task must not be missed, record when it last succeeded and check that on start-up.

Timezones

Celery uses UTC unless you set timezone to an IANA zone name, the same names Python’s zoneinfo module uses. Set it once:

app.conf.timezone = "Asia/Kolkata"

After that, crontab(hour=9, minute=0) means 9:00 am in India. Without it, the same line runs at 2:30 pm Indian time. India has no daylight saving, so the time stays fixed all year.

In Django, the setting is CELERY_TIMEZONE when you load Celery’s settings from Django with the CELERY namespace. If you do not set it, Celery’s periodic tasks guide says Django’s TIME_ZONE is used.

If you change the timezone later, the default file scheduler notices and resets itself. The Django database scheduler does not, so reset its last-run times by hand:

python manage.py shell -c "from django_celery_beat.models import PeriodicTask; PeriodicTask.objects.update(last_run_at=None)"

Storing the schedule in Django’s database

The django-celery-beat package keeps schedules in your database, so you can add or change them from the Django admin without redeploying:

pip install django-celery-beat
celery -A proj beat --scheduler django_celery_beat.schedulers:DatabaseScheduler

It changes where the schedule lives, not how many beats you may run. Still run exactly one.

Running beat in production

• One beat process, always. Run it as its own service with a single instance, separate from your web app and your workers.
• Do not use worker -B in production unless you are certain only one such worker exists. Celery’s own docs say it “isn’t recommended for production use”.
• Keep the schedule file on disk if you use the default scheduler, or use the database scheduler, so last-run times survive restarts.
• Make sure a worker listens on the task’s queue. If a task is routed to a queue no worker consumes, beat keeps sending it and nothing runs, with no error.
• Make tasks idempotent. A restart, a retry or a second beat can all cause a repeat run.
• Watch the effect. Check that the report was written or the email sent, not just that beat logged a message.

On Voroa, run beat as a background worker with one instance, and your Celery workers as another. Both reach Redis on its internal address in Mumbai.

A service’s files on Voroa are reset on every deploy, so beat’s schedule file does not survive one. Use the django-celery-beat database scheduler, or record each task’s last success in your database. Our Celery and Redis guide covers the worker side, including idle command costs.

If a job is a simple script, a Voroa Cron Job can run it on a schedule without beat at all. Schedules are in IST. See scheduling a task on Voroa and worker or cron job. For the same duplicate-run test in a pure-Python scheduler, see our APScheduler guide.

FAQ

Is Celery beat the same as a Celery worker? No. Beat only schedules: it sends due tasks to the broker. A worker runs them. You need one beat and at least one worker for periodic tasks.

Why are my Celery periodic tasks running twice? Usually because two beat processes are running. In our test, two beats doubled every task. Run exactly one.

Does Celery beat run missed tasks after a restart? Not the missed ones. In our test it skipped the runs it missed, and a run came 0.6 seconds after it started. Whether an overdue run fires depends on the schedule file surviving the restart.

Should I run beat with worker -B? Only in development. In production, run beat as its own single process.

How do I set the timezone for Celery beat? Set timezone in the Celery configuration, for example Asia/Kolkata. Otherwise schedules use UTC.

Can I change schedules without redeploying? Yes, with django-celery-beat, which stores schedules in the database and shows them in the Django admin.

Tested 7 November 2026 with Celery 5.7.0 and Redis 8.10.3; definitions and settings re-checked against the Celery 5.7 docs on 14 November 2026. Found something out of date? Write to support@getvoroa.com.

On this page

• How Celery uses Redis
• A minimal working setup
• Django in six lines
• What an idle worker costs, measured
• What each task costs, measured
• Results: keep them only if you read them
• The visibility timeout trap
• Settings for production
• Choosing a Redis for Celery
• FAQ

How Celery uses Redis

Redis plays two separate roles, and you can use one or both:

• Broker. Your web app puts a task message on a Redis list. Workers take messages off the list and run them. Without a broker there is no Celery.
• Result backend. When a task finishes, Celery can store its return value and state in Redis so your app can read it later. This is optional, and often unnecessary.

A minimal working setup

pip install "celery[redis]"

# tasks.py
import os
from celery import Celery

app = Celery(
    "tasks",
    broker=os.environ["REDIS_URL"],          # e.g. redis://:password@host:6379/0
    backend=os.environ.get("RESULT_URL"),    # optional; leave unset if you never read results
)

@app.task(bind=True, max_retries=5, default_retry_delay=10)
def send_welcome_email(self, user_id):
    try:
        deliver_email(user_id)               # your code
    except TemporaryError as exc:
        raise self.retry(exc=exc)

Start a worker in its own process:

celery -A tasks worker --loglevel=info --concurrency=4

And queue work from your app:

send_welcome_email.delay(user.id)

For a TLS connection, use a rediss:// URL. For the result backend, add the certificate setting to the URL, for example rediss://:password@host:6380/1?ssl_cert_reqs=required, or Celery refuses it.

Django in six lines

# settings.py
CELERY_BROKER_URL = os.environ["REDIS_URL"]
CELERY_TASK_IGNORE_RESULT = True
CELERY_TASK_ACKS_LATE = True
CELERY_TASK_REJECT_ON_WORKER_LOST = True
CELERY_WORKER_PREFETCH_MULTIPLIER = 1

With the usual celery.py in your project (app.config_from_object("django.conf:settings", namespace="CELERY") and app.autodiscover_tasks()), any @shared_task in your apps is picked up. Each setting above is explained below.

What an idle worker costs, measured

Setup: Celery 5.7.0, kombu 5.7.0 and redis-py 8.1.0 on Python 3.14, on a Windows laptop, using the solo pool because Celery’s default pool does not run on Windows. Redis 8.10.3 ran in a Linux virtual machine (WSL2) on the same laptop. We counted commands with Redis’s own command statistics. Measured 7 November 2026.

We started one worker with nothing to do, let it settle for 20 seconds, then counted for two minutes.

An idle Celery worker polls the broker for new tasks and talks to other workers every few seconds. That is normal, and on a store that limits memory it costs nothing. On a host that charges per command, it is the bill: 4.3 million is more than eight times a 500,000-command free allowance, before a single task runs. The same is true of Node.js queues; our BullMQ measurements found about 110 commands a minute for an idle worker there.

What each task costs, measured

The commands-per-task figures include the worker’s normal polling during the run, so treat them as upper bounds. Turning results off removed roughly 8 commands per task and all of the leftover memory.

Results: keep them only if you read them

By default, every result is kept in Redis for one day. We checked: a result key had a remaining lifetime of 86,396 seconds straight after the task finished.

At about 383 bytes each, 100,000 tasks a day keeps around 38 MB of results in memory at any time, which is nearly a third of a 128 MB store, holding values nobody reads. Most tasks, such as sending an email or resizing an image, do not need a stored result at all.

• Set task_ignore_result = True globally, and turn results on only for the tasks whose return value you actually fetch.
• If you do keep results, lower result_expires to how long you really need them, for example one hour.
• If you need to track progress for a user, store it in your database or publish it, rather than polling the result backend.

The visibility timeout trap

With Redis as the broker, a worker takes a task but Redis does not know whether it finished. Celery handles this with a visibility timeout, one hour by default: if a task has not been acknowledged within that time, it is given to another worker.

Two things follow:

• A task that runs longer than an hour can run twice. If you have long reports or exports, raise the timeout above your longest task with broker_transport_options = {"visibility_timeout": 7200}.
• Tasks scheduled far in the future are redelivered. A task with a countdown or eta longer than the visibility timeout can be handed out again before it is due. For anything scheduled hours ahead, use a scheduled task or Celery beat instead of a long countdown.

Either way, write tasks so that running twice is harmless: check whether the email was sent or the invoice created before doing it again.

Settings for production

Even with both settings, if the whole worker machine or container dies, its unacknowledged tasks come back only after the visibility timeout, up to an hour by default.

Run the worker as its own long-running process, not inside your web server. On Voroa that is a background worker, which never sleeps; the steps are in deploying a background worker, and the Redis URL goes in an environment variable.

Choosing a Redis for Celery

1. Limited by memory, not commands. As measured above, idle workers send millions of commands a month.
2. No eviction. If the store deletes keys when full, queued tasks can vanish. Use a policy that refuses writes instead; see Redis eviction policies.
3. Data kept on disk. A store that empties on restart loses every queued task.
4. The same region as the worker. Every task fetch is a round trip; a store in another country slows every one.

Celery should work the same on Redis and Valkey, since it uses core list and key commands; test with your own tasks before you switch. our Valkey vs Redis comparison covers where the two differ. On Voroa, a key value store defaults to Keep everything when memory is full, keeps data on disk with a nightly snapshot, and runs in Mumbai beside your workers. See the Key Value guide.

Run Celery and its Redis in one place

Your Django or Flask app, the Celery worker and a Redis-compatible store, side by side in Mumbai, with a free store size to start. See the sizes on the managed Redis page.

FAQ

Do I need a result backend for Celery? No. Only if your app reads task return values. Without one, tasks still run; set task_ignore_result = True.

Why is my Redis memory growing with Celery? Usually stored results, which are kept for a day by default. Ignore results you do not read, or lower result_expires.

Why did my Celery task run twice? With Redis as the broker, a task not acknowledged within the visibility timeout (one hour by default) is redelivered. Long tasks and long countdowns are the usual cause.

Can I use the same Redis for the broker and results? Yes, ideally on separate database numbers or key prefixes. On a small store, keep results off so they do not compete with the queue for memory.

Does Celery work on Windows? For development, with --pool=solo. Run production workers on Linux.

Is Redis or RabbitMQ better for Celery? Redis is simpler to run and fine for most apps. RabbitMQ gives stronger delivery guarantees without a visibility timeout and suits very high volumes or complex routing.

Measured 7 November 2026 with Celery 5.7.0 and Redis 8.10.3. Found something out of date? Write to support@getvoroa.com.

The rest of this guide covers what catches people out later. Some step values give uneven gaps, a slow job can overlap the next run, and several hosting platforms will not run a job that often at all.

On this page

• Every-N-minutes expressions
• What */5 actually means
• The step values that give uneven gaps
• When a 5-minute job takes 7 minutes
• Can cron run every 30 seconds?
• Each platform’s minimum interval
• FAQ

Every-N-minutes expressions

The offset form is useful when many jobs share a server. Starting at minute 2 keeps your job away from the busy top of the hour.

What */5 actually means

*/5 in the minute field means “every minute divisible by 5”: 0, 5, 10 and so on up to 55. It is tied to the clock, not to when you saved the job.

So a job added at 10:03 first runs at 10:05, not 10:08. And it always runs at the same minutes past the hour, which makes logs easy to read.

The step values that give uneven gaps

Steps restart at the top of every hour. That is fine for numbers that divide 60 evenly: 2, 3, 4, 5, 6, 10, 12, 15, 20 and 30. For any other step, the last gap of the hour comes out shorter.

We generated the real run times for a day with the croniter library, which follows standard cron rules:

If you need “every 7 minutes” exactly, cron cannot express it. Run every minute and let the script skip until 7 minutes have passed since its last run, or use a scheduler with an interval trigger, such as APScheduler in Python.

When a 5-minute job takes 7 minutes

Cron starts each run on time, whether or not the last one has finished. A job that usually takes 2 minutes but once takes 7 will still be running when the next copy starts.

Two copies working on the same rows can send duplicate emails or corrupt a count. On a Linux server, flock stops the second copy from starting:

*/5 * * * * flock -n /tmp/sync.lock /usr/local/bin/sync.sh

flock -n exits at once if the lock is held, so an overlapping run is skipped rather than queued. In application code, the same idea is a lock key in Redis or your database. Our Node.js cron tests measured three copies of a slow job running at once without one.

Can cron run every 30 seconds?

Standard cron’s smallest unit is one minute. To run every 30 seconds, add a second entry that sleeps first:

* * * * * /usr/local/bin/task.sh
* * * * * sleep 30; /usr/local/bin/task.sh

If you need sub-minute timing regularly, a long-running process with an in-app scheduler or a queue is usually cleaner than stacking cron lines. Some libraries, such as node-cron, accept an optional seconds field.

Each platform’s minimum interval

Your cron expression is only half the story. Many hosts set a floor on how often a job may run, and some do not promise exact timing.

Sources: the GitHub Actions schedule docs, the Vercel cron usage page and the Heroku Scheduler documentation, all checked on 7 November 2026. Vercel describes Cron Jobs as moving to a newer Schedules feature.

Two of these matter for India. On a UTC platform, */5 9-18 * * 1-5 means 2:30 pm to 12:25 am IST, not office hours. And on GitHub Actions, scheduled workflows in a public repository are turned off after 60 days with no activity.

Run a 5-minute job on Voroa

Voroa runs Cron Jobs and Scheduled Tasks on schedules down to every minute, and the presets include Every minute and Hourly. Schedules are in India Standard Time, so */5 9-18 * * 1-5 means 9 am to 6:55 pm IST on weekdays.

Runs happen inside a service that stays running, so a slow run can overlap the next one. Use a lock as shown above. Setup is in scheduling a task on Voroa, and long-running processes are covered on the background workers page. Not sure which type your code needs? See worker or cron job.

FAQ

How do I run a cron job every 5 minutes? Use */5 * * * *. It runs at minutes 0, 5, 10 and so on, every hour, 288 times a day.

Is */5 the same as “5 minutes after the last run”? No. It runs at clock minutes divisible by 5. A job added at 10:03 first runs at 10:05.

Why does my */7 job run 4 minutes apart sometimes? Steps restart every hour. After minute 56, the next run is minute 0, only 4 minutes later.

How do I stop a cron job from overlapping? On Linux, wrap the command in flock -n. In code, take a lock in Redis or your database before doing the work.

Can GitHub Actions run a cron every minute? No. The shortest interval is every 5 minutes, and runs can be delayed during busy periods.

What timezone does cron use? The server’s, which is usually UTC on cloud platforms. To run at 9 am IST on a UTC server, write the UTC time: 30 3 * * *. Or use a platform that schedules in IST.

Checked 7 November 2026. Found something out of date? Write to support@getvoroa.com.

This guide shows those lines, then what we saw when we tested the parts tutorials skip. Two app instances, a slow job and a restart each changed the result.

On this page

• Set up node-cron in five lines
• Reading a cron expression
• Test 1: two instances run every job twice
• Test 2: a slow job piles up
• Test 3: a restart skips runs
• Timezones: the 2:30 pm surprise
• In-process cron or a separate cron job?
• FAQ

Set up node-cron in five lines

npm install node-cron

import cron from 'node-cron';

cron.schedule('0 9 * * *', async () => {
  await sendDailyDigest();            // your code
}, { timezone: 'Asia/Kolkata' });

That runs sendDailyDigest at 9:00 am India time, every day, for as long as the process stays up. The callback can be async. Errors inside it do not stop the schedule, so catch and log them yourself.

Reading a cron expression

A standard expression has five fields. node-cron also accepts an optional sixth field for seconds at the front.

Some patterns you will use often:

Test 1: two instances run every job twice

Setup for all tests: node-cron 4.6.0 on Node.js 24, a schedule that fires every second so results show up quickly, and Redis 8.10.3 to count runs. Measured 7 November 2026 on a laptop.

This is a common problem. You scale a web app to two instances for reliability. Each instance loads the same code, so each one starts its own copy of the schedule.

With two instances, every scheduled job ran twice. For a cleanup that is harmless. For a daily digest it means every user gets two emails. For a billing job it means two charges.

The fix is to let only one instance do the work for each scheduled time. A short lock in Redis does it:

cron.schedule('0 9 * * *', async () => {
  const slot = new Date().toISOString().slice(0, 16);           // one key per minute
  const won = await redis.set(`lock:digest:${slot}`, '1', 'NX', 'EX', 300);
  if (!won) return;                                              // another instance has it
  await sendDailyDigest();
});

SET ... NX succeeds for only one caller, so exactly one instance runs the job. In our test the lock cut 40 runs back to 20.

Test 2: a slow job piles up

Next, a job that takes 2.5 seconds, scheduled every second. In real life, think of a report that usually takes 4 minutes, scheduled every 5, on a day it takes 7.

By default, node-cron starts the next run even if the last one has not finished. Three copies of the job were running at once. If each one reads and writes the same rows, they get in each other’s way.

The noOverlap option skips a run while the previous one is still going:

cron.schedule('*/5 * * * *', buildReport, { noOverlap: true });

That is usually what you want. The cost is that a skipped run is skipped, not delayed.

Test 3: a restart skips runs

Finally, we stopped the only instance for 5 seconds, as a deploy or a crash would, and started it again.

node-cron keeps its schedule in memory. While the process is down, nothing runs, and nothing catches up when it comes back. A deploy at 1:59 am can silently skip your 2 am backup.

For a job that must run, record when it last succeeded, for example a row in your database. On start-up, check that time and run the job if it is overdue.

One good result: timing was accurate. Across the tests, runs fired a median of 7 to 12 ms after the scheduled second, and the 99th percentile stayed between 15 and 35 ms.

Timezones: the 2:30 pm surprise

node-cron uses the server’s timezone unless you pass one. Most cloud servers and containers run on UTC. So 0 9 * * * fires at 9:00 UTC, which is 2:30 pm in India.

Always set timezone: 'Asia/Kolkata' if you mean Indian time. India has no daylight saving, so the time never shifts during the year. Zones with daylight saving can skip or repeat an hour twice a year.

In-process cron or a separate cron job?

Running cron inside your web app is fine for small, safe jobs. It gets risky as soon as you run more than one instance or the job matters.

A separate cron job is its own process with one instance, so it does not care how many web instances you have. Overlap and missed runs (Tests 2 and 3) can still happen there, so keep jobs safe to run twice.

For queued work that should run as soon as possible, a job queue fits better; see our Redis job queue guide.

Run a Node.js cron job on Voroa

On Voroa you can create a Cron Job straight from your repository: give it a command such as node scripts/digest.js and a schedule. Voroa builds the repository into a small service that stays running and runs your command inside it on schedule. It is separate from your web services, so scaling the app never doubles a job.

Two things to plan for. Runs reuse the same running container rather than a fresh one each time, and a slow run can overlap the next. And if the service is stopped, scheduled runs are skipped, not caught up later. Keep jobs idempotent and record the last successful run, as in Test 3.

Schedules run in India Standard Time, so 0 9 * * * means 9:00 am IST. Setup is in scheduling a task on Voroa, and worker or cron job helps you pick the right type. More on long-running processes is on the background workers page.

FAQ

How do I run a cron job in Node.js? Install node-cron, call cron.schedule(expression, function), and keep the process running. Use the timezone option for local time.

Why does my Node.js cron job run twice? Usually because the app runs on two instances, or the process started twice. In our test, two instances ran every job twice. Use a lock or a separate cron job.

Does node-cron run missed jobs after a restart? No. It keeps the schedule in memory, so runs during downtime are skipped. Track the last successful run yourself if a job must not be missed.

How do I stop overlapping runs in node-cron? Pass { noOverlap: true }. A run is skipped while the previous one is still in progress.

What timezone does node-cron use? The server’s, usually UTC in the cloud. Pass timezone: 'Asia/Kolkata' for Indian time.

node-cron or a cron job service? node-cron for small in-app tasks. A separate cron job for jobs that must not run twice because the app scaled, or must survive app deploys. Keep them idempotent either way.

Tested 7 November 2026 with node-cron 4.6.0 and Node.js 24. Found something out of date? Write to support@getvoroa.com.

This guide starts with the six steps, then shows all three ways with working code, and the traps we hit when testing them on Python 3.14: a script that imports fine in your terminal but not under cron, and a scheduler that drifts.

On this page

• How to write a cron job in Python
• Reading the five time fields
• Which way should you pick?
• Way 1: a crontab line
• The virtualenv trap, measured
• Way 2: write the crontab from Python
• Way 3: a scheduler inside your program
• The schedule library drifts
• Running it in Docker
• FAQ

How to write a cron job in Python

These steps work on any Linux server or Mac with cron. The example runs digest.py every day at 9 am, server time.

1. Write the script and use absolute paths inside it. Cron starts your job in your home directory, so a relative path such as open("data.csv") points to the wrong place.

   pythonCopy

   # /srv/app/digest.py
   from datetime import datetime
   from pathlib import Path
   
   HERE = Path(__file__).resolve().parent
   (HERE / "digest-last-run.txt").write_text(f"{datetime.now():%Y-%m-%d %H:%M:%S}\n")
   print("digest done")
   

2. Find the full path of the Python that has your packages. Inside a virtualenv it is .venv/bin/python in your project. Print it once so you can copy it:

   bashCopy

   cd /srv/app && realpath .venv/bin/python
   

3. Run the script with that path, exactly as cron will. If this fails, cron will fail too:

   bashCopy

   /srv/app/.venv/bin/python /srv/app/digest.py
   

4. Open your crontab with crontab -e. It opens in your editor; each line is one job.

5. Add one line: the schedule, then the command, with output sent to a log.

   Copy

   0 9 * * * cd /srv/app && /srv/app/.venv/bin/python digest.py >> /srv/app/digest.log 2>&1
   

6. Save, then check. crontab -l lists the job. After 9 am, look in digest.log for digest done. If it is empty, the first error line in that log tells you why.

That is a complete Python cron job. The rest of this page explains each choice in that line, and the other two ways to schedule Python.

Reading the five time fields

A crontab line starts with five fields, in this order: minute, hour, day of month, month and day of week. A * means “every”. Common schedules:

Two details catch people out. A step only counts inside its own field, so */35 in the minute field runs at :00 and :35, not every 35 minutes. And a % in the command is turned into a newline by cron, so a command such as date +%F must be written date +\%F. Both rules are in the crontab(5) manual.

Which way should you pick?

If you are not sure, use Way 1. The operating system starts your script, so nothing has to stay running.

Way 1: a crontab line

Run crontab -e and add one line. This runs digest.py every day at 9 am, server time:

0 9 * * * cd /srv/app && /srv/app/.venv/bin/python digest.py >> /var/log/digest.log 2>&1

Three details in that line prevent most failures. It calls the virtualenv’s own Python by its full path, it changes to the project folder first, and it sends output and errors to a log file. Make sure the user that owns the crontab can write to that log path; /var/log often needs root, so a log inside your project folder is the easy choice.

The virtualenv trap, measured

Cron does not load your shell, so it does not see an activated virtualenv. We reproduced cron’s empty environment with env -i PATH=/usr/bin:/bin and ran a script whose package was installed only in the virtualenv:

So call the virtualenv’s interpreter directly, not python3 and not source activate. And use absolute paths, or cd first, because cron starts your job in your home directory. Python’s venv documentation confirms that running the venv’s interpreter directly is enough; activation is optional.

Environment variables such as DATABASE_URL are missing for the same reason. Load them inside the script, for example from a .env file. Our cron troubleshooting checklist covers the other causes.

Way 2: write the crontab from Python

The python-crontab package edits crontab files from code. It is useful when your program installs its own schedule, for example a CLI tool’s setup command:

from crontab import CronTab

cron = CronTab(user=True)
job = cron.new(
    command="/srv/app/.venv/bin/python /srv/app/digest.py >> /var/log/digest.log 2>&1",
    comment="digest",
)
job.setall("30 3 * * *")
cron.write()

Tested with python-crontab 3.4.0, it renders this line, with a comment so you can find and remove the job later:

30 3 * * * /srv/app/.venv/bin/python /srv/app/digest.py >> /var/log/digest.log 2>&1 # digest

Nothing is saved until cron.write() runs. It is still a normal cron job, so the virtualenv and timezone rules above apply. Note 30 3: on a UTC server that is 9 am in India, as our cron timezone guide explains.

Way 3: a scheduler inside your program

If your app already runs all the time, a library can call functions on a timer, with no crontab at all. The two common choices:

• schedule: tiny and readable, schedule.every().day.at("09:00").do(job). No cron expressions, and no persistence.
• APScheduler: cron expressions, timezones and optional job stores. Our APScheduler guide covers its restart and duplicate-run traps.

For Django or Flask apps that already use Celery, Celery beat is the usual fit.

Every in-process scheduler shares one rule: it runs once per copy of your program. Run the app on two servers, or with four Gunicorn workers that each start the scheduler, and each job runs two or four times.

The schedule library drifts

We scheduled schedule.every(5).seconds.do(job) with a job that takes 2 seconds, and ran it for 40 seconds with schedule 1.2.2.

The gap was 7 seconds, not 5: the library counts the next interval from when the job finished. In 40 seconds that is 6 runs instead of 8. For “every few minutes, roughly” that is fine. For “exactly on the hour”, use a cron expression instead.

Running it in Docker

A standard Python image has no cron daemon. Writing a crontab inside the container does nothing unless you install cron and run it as the main process, which also hides your environment variables from the job.

The simpler options: run the script from the host’s cron with docker run, use an in-process scheduler in a container that stays up, or use your platform’s scheduled job feature.

Python cron jobs on Voroa

On Voroa, a Cron Job builds your repository and runs a command such as python digest.py on a schedule, read in India Standard Time. Your environment variables are already set, so the virtualenv and .env traps above do not apply.

The command runs inside a service that stays running, so a slow run can overlap the next, and runs are skipped while the service is stopped. See scheduling a task on Voroa and the Django deploy guide. Long-running consumers go on the background workers page.

FAQ

How do I create a cron job for a Python script? Run crontab -e, add a line with the schedule and the full path to your Python and script, for example 0 9 * * * /full/path/to/.venv/bin/python /full/path/to/script.py >> /full/path/to/script.log 2>&1, and save. crontab -l confirms it is installed.

Why does my Python script work in the terminal but not in cron? Usually the wrong interpreter. Cron uses the system python3, which cannot see packages in your virtualenv. Call the venv’s Python by its full path.

Do I need to activate the virtualenv in cron? No. Running .venv/bin/python directly uses the virtualenv’s packages.

Do I need a shebang line or chmod +x? Not if the crontab line starts with the interpreter, as in the examples here. You only need both if the line calls the script on its own, such as /srv/app/digest.py.

Can Python run cron jobs without crontab? Yes, with an in-process library such as schedule or APScheduler, as long as your program keeps running.

How do I see the output of a Python cron job? Redirect it: >> /srv/app/job.log 2>&1. Without that, cron mails the output to the crontab’s owner, or it is lost if no mail is set up.

Tested on Python 3.14 with schedule 1.2.2 and python-crontab 3.4.0 on 7 November 2026; steps and crontab rules reviewed 14 November 2026. Found something out of date? Write to support@getvoroa.com.

The cause is almost always one of a short list. Work through the checks below in order. The first few take seconds, and together they cover the vast majority of cases.

On this page

• First: did it run at all?
• Checks 1-4: is cron set up?
• Checks 5-8: does the command work under cron?
• Checks 9-12: is it running at the wrong time, or twice?
• Extra traps on hosted platforms
• A crontab line that avoids most of this
• FAQ

First: did it run at all?

Before changing anything, find out whether cron started the job and it failed, or never started it.

grep CRON /var/log/syslog          # Debian and Ubuntu
journalctl -u cron --since today   # systemd (the unit is crond on RHEL-family systems)

A line with your command means cron started it, so the problem is inside the command (checks 5 to 8). No line means cron never ran it (checks 1 to 4 and 9).

Checks 1-4: is cron set up?

1. Is the cron daemon running? On Ubuntu, systemctl status cron. In a minimal Docker container there is usually no cron daemon at all unless you start one.

2. Is the job in the crontab you think? Run crontab -l as the same user. A job added with sudo crontab -e lives in root’s crontab, not yours.

3. Is the syntax right? Standard cron takes five time fields. A sixth field for seconds, copied from a library such as node-cron, makes the line invalid. Files in /etc/cron.d/ also need a user name before the command.

4. Does the file end with a newline? Cron can ignore a last line with no newline after it. Press Enter after the final job.

Checks 5-8: does the command work under cron?

5. The PATH is short. Cron runs with a minimal PATH, often just /usr/bin:/bin. A command such as node, python3 or php installed elsewhere is not found. Use full paths (which node shows it), or set PATH= at the top of the crontab.

6. Your environment is not loaded. Cron does not read .bashrc or .profile. Variables such as DATABASE_URL that you export in your shell are missing. Load them explicitly in the script.

7. The % sign is special. In a crontab, % means “new line”. A command such as date +%Y-%m-%d breaks unless you write \%. Moving the command into a script avoids it.

8. Permissions and the working directory. The script must be executable (chmod +x), and cron starts in your home directory. A script that opens config.json by relative path fails. cd to the right folder first.

Checks 9-12: is it running at the wrong time, or twice?

9. The timezone. Cron uses the server’s timezone, usually UTC in the cloud. A job meant for 9 am in India written as 0 9 * * * runs at 2:30 pm. Write 30 3 * * *, or change the server timezone.

10. Day-of-month and day-of-week. If both are set, standard cron runs when either matches. 0 9 1 * 1 runs on the 1st and every Monday, which looks like “running at random”.

11. Overlapping runs. A slow run is still going when the next one starts. They clash, and one seems to fail. Wrap the command in flock -n /tmp/job.lock so a second copy is skipped.

12. It runs on two machines. The same crontab on two servers, or an in-app scheduler in two instances, runs every job twice. We measured exactly that with node-cron and APScheduler.

Extra traps on hosted platforms

Sources: the GitHub Actions schedule docs and each platform’s own documentation. More detail per platform is in our posts on Vercel cron jobs and Heroku Scheduler.

A crontab line that avoids most of this

SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
CRON_TZ=Asia/Kolkata

30 9 * * * cd /srv/app && flock -n /tmp/digest.lock ./bin/digest >> /var/log/digest.log 2>&1

It sets a shell and a PATH, runs from the right folder, takes a lock, and logs both output and errors. CRON_TZ is honoured by cronie (Fedora, RHEL); Ubuntu’s default cron ignores it, so check yours.

On Voroa

A Voroa Cron Job or Scheduled Task runs your command inside a service that stays running, with your environment variables already set and schedules in India Standard Time. That removes checks 5, 6 and 9, though the container’s own clock may still read UTC if your job reads the date.

Voroa does not show per-run output for a scheduled command, so make the job record its result somewhere you can check, such as a database row. See scheduling a task on Voroa and worker or cron job. Long-running processes are covered on the background workers page.

FAQ

Why is my cron job not running? Most often: a missing PATH, a missing environment variable, a timezone difference, or the job is in a different user’s crontab. Check the cron log first to see whether it started at all.

How do I check if cron ran my job? Look for your command in /var/log/syslog (Debian, Ubuntu) or journalctl -u cron, and send the job’s own output to a log file.

Why does my script work in the terminal but not in cron? Cron has a short PATH, does not load your shell profile, and starts in your home directory. Use full paths and load your variables in the script.

Why does my cron job run at the wrong time? The server is probably on UTC. For 9 am IST on a UTC server, write 30 3 * * *.

How do I stop a cron job running twice? Use flock -n against overlap, and make sure only one machine or one scheduler instance runs the job.

Does cron run if the server was off? No. Standard cron does not catch up missed runs. systemd timers can, with Persistent=true.

Updated 7 November 2026. Found something out of date? Write to support@getvoroa.com.

This guide shows how to convert correctly, the two traps that a simple “subtract 5:30” misses, and how each platform and library lets you set the zone. The conversions below were generated with Python’s zoneinfo, not worked out by hand.

On this page

• Which timezone does cron use?
• IST to UTC conversion table
• Trap 1: before 5:30 am IST, the day changes
• Trap 2: the first of the month
• Setting the timezone, platform by platform
• Setting it in code
• The schedule and the clock are not the same
• FAQ

Which timezone does cron use?

Classic Linux cron uses the server’s system timezone. Check it with:

timedatectl          # or: date

Most cloud servers and containers are set to UTC. Most hosted schedulers also use UTC by default. India Standard Time is UTC plus 5 hours 30 minutes, all year: India has no daylight saving, so the offset never changes.

IST to UTC conversion table

For a job you want on Monday in India:

For daily jobs drop the last field: 9 am IST every day is 30 3 * * *.

Ranges convert the same way. “Every hour from 9 am to 6 pm IST” is 30 3-12 * * *. Because of the half hour, it fires at 30 minutes past each UTC hour, which is on the hour in India.

Trap 1: before 5:30 am IST, the day changes

Look at the top of the table. Anything earlier than 5:30 am in India happens on the previous day in UTC.

So a “Monday 2 am” backup written as 30 20 * * 1 runs on Tuesday 2 am in India. The correct line is 30 20 * * 0, with Sunday as the day. Weekday ranges shift too: “2 am IST, Monday to Friday” becomes 30 20 * * 0-4.

This is the most common reason a weekly job seems to run on the wrong day.

Trap 2: the first of the month

The same shift hits dates. “2 am IST on the 1st of every month” is 20:30 UTC on the last day of the previous month.

Standard cron cannot say “last day of the month”, because months have 28 to 31 days. You have two options: run the job at 5:30 am IST or later, so the date stays the same in UTC, or use a scheduler that lets you set the timezone to Asia/Kolkata.

Setting the timezone, platform by platform

Sources: each platform’s documentation, checked on 7 November 2026, including the GitHub Actions events page. Platform details are in our posts on Vercel cron jobs and Heroku Scheduler.

Setting it in code

In-app schedulers take a timezone option. Use the IANA name Asia/Kolkata; avoid fixed offsets such as +05:30 where a name is accepted.

// node-cron
cron.schedule('0 9 * * *', job, { timezone: 'Asia/Kolkata' });

# APScheduler
BlockingScheduler(timezone="Asia/Kolkata")

# Celery beat
app.conf.timezone = "Asia/Kolkata"

Without the option, node-cron and APScheduler fall back to the server’s zone, usually UTC. Celery falls back to UTC whatever the server’s zone is. Our tests of node-cron, APScheduler and Celery beat cover the other things these schedulers get wrong.

The schedule and the clock are not the same

Setting the schedule’s timezone decides when the job starts. It does not change the clock your code reads inside the job.

A job scheduled for 9 am IST can still see a UTC time from new Date().getHours() or a naive datetime.now() if the container runs on UTC. If your job names a file by date or picks “yesterday’s” records, set the zone in the code too, or use timezone-aware functions with Asia/Kolkata.

Cron jobs in IST on Voroa

Voroa’s Cron Jobs and Scheduled Tasks read schedules in India Standard Time, so 0 9 * * * means 9:00 am IST and 0 2 * * 1 means Monday 2 am IST, with no conversion.

The container’s own clock may still be UTC, as above, so read the date carefully inside the job. Runs are skipped while the service is stopped, and a slow run can overlap the next, so keep jobs safe to run twice. See scheduling a task on Voroa, and the background workers page for long-running processes.

FAQ

What timezone does cron use? The server’s system timezone. On most cloud servers and hosted schedulers that is UTC.

How do I convert IST to UTC for cron? Subtract 5 hours 30 minutes. 9 am IST is 30 3 * * *. For times before 5:30 am IST, also move the day back by one.

Why does my Monday cron job run on Tuesday? It is set for early morning IST but written with Monday in UTC. Early IST hours are the previous UTC day, so write Sunday.

Can I set a timezone in a crontab? With cronie, yes, using CRON_TZ=Asia/Kolkata. Ubuntu’s default cron ignores it, so change the system timezone instead.

Does India have daylight saving time? No. IST is UTC plus 5:30 all year, so a converted schedule never needs adjusting.

Which timezone name should I use for India? Asia/Kolkata. It is the IANA name that libraries and platforms accept.

Conversions generated with Python zoneinfo on 7 November 2026. Found something out of date? Write to support@getvoroa.com.

On this page

• How ElastiCache charges
• Node prices in Mumbai, in rupees
• Serverless: the minimum decides small bills
• Valkey or Redis OSS: the same cache, a different price
• What a real setup costs
• The costs that are not on the price card
• Is there a free tier?
• Alternatives priced in rupees
• FAQ

How ElastiCache charges

There are two ways to buy it:

1. Node-based (self-designed) clusters. You pick an instance size and pay for every hour each node runs, whether it is busy or idle. A replica for failover is another node at the same price.
2. Serverless. No sizes to pick. You pay for the data you store, per GB-hour, plus the requests you send, in ElastiCache Processing Units (ECPUs). Each cache has a minimum amount of data you are billed for, even if you store less.

Backup storage beyond the free allowance, and data sent between Availability Zones or out of AWS, are billed separately.

How we converted. AWS publishes Mumbai prices in US dollars. We multiplied by 730 hours for a month and converted at Rs 93.92 per dollar, the European Central Bank reference rate for 6 November 2026. If your account is billed by AWS India, your invoice is in rupees at AWS’s own rate and adds 18% GST, so treat the rupee figures as close estimates before GST. The dollar prices are exact, from the ElastiCache pricing page and AWS’s price list file.

Node prices in Mumbai, in rupees

On-demand, per node, Mumbai region, before GST.

Two things to know about these sizes. The memory figure is the whole node, and part of it is needed by the engine itself and for background saves, so plan to fill no more than about three-quarters of it. And the t4g sizes are burstable: they suit steady light traffic, not sustained heavy load.

Serverless: the minimum decides small bills

For a small app this table is the whole story. A Redis OSS serverless cache costs at least about Rs 5,553 per month before GST even if it holds one key, because you pay for 1 GB regardless. The same cache on Valkey starts at about Rs 370. Requests are cheap at small scale: 100 million ECPUs cost about $0.15 on Valkey.

Above the minimum, serverless costs about $39.42 (about Rs 3,702) per GB stored per month on Valkey. A cache that holds more than a few GB around the clock is usually cheaper on nodes; one that is small or spiky is usually cheaper serverless.

Valkey or Redis OSS: the same cache, a different price

On every line above, Valkey is cheaper: 20% less on nodes, 33% less on serverless storage and 32% less on requests, and a minimum one-tenth the size. Both speak the same protocol, so your client library does not change.

The reasons to stay on Redis OSS are narrow: data files from Redis 7.4 or later that you need to load directly, or features that exist only in newer Redis releases. We covered the differences, with a benchmark, in Valkey vs Redis. For most caches on AWS today, Valkey is the default choice on price alone.

What a real setup costs

Three common shapes, Mumbai, Valkey, before GST:

Add 18% GST on an AWS India invoice. A replica doubles the node cost, and with Multi-AZ automatic failover turned on it takes over when the primary fails; without one, a node failure means downtime and an empty cache.

The costs that are not on the price card

• Reaching it from outside AWS. ElastiCache is reached from inside your AWS network (VPC). If your app runs somewhere else, you need extra networking, and its cost and latency, to connect at all.
• Data transfer. Traffic between your app and the cache in the same Availability Zone is free; traffic across zones is billed per GB in each direction. A replica in another zone, or an app spread across zones, adds to it.
• Backups. Snapshots beyond the free allowance cost $0.085 per GB-month in Mumbai.
• Your time. Sizing nodes, setting parameter groups, VPC security rules and upgrade windows are yours to manage on the node-based option.

Is there a free tier?

New AWS accounts created since 15 July 2025 get credits rather than a permanent free cache: $100 at sign-up and up to $100 more, which AWS says can be used towards ElastiCache, for up to 6 months, with a card required. After that you pay the prices above. For a free cache with no end date, our free Redis hosting comparison lists eight options and the catch in each.

Alternatives priced in rupees

If your app does not run on AWS, or you want a bill in rupees with no conversion, a managed store outside AWS can be simpler. For comparison, Voroa’s key value sizes, set in rupees and billed with a GST invoice:

The same caution as for ElastiCache applies, more strongly: the memory figure is the whole instance, and Voroa can hold back up to 40% of it for the nightly save, so a 1 GB store may hold about 600 MB of data. Compare usable data, not the label, when you weigh the two.

These are single instances with data written to disk and a nightly snapshot, not a primary-plus-replica cluster, so compare them with a single ElastiCache node rather than a failover pair. They run in Mumbai next to the web services you deploy, reached over a private network. The full details are on the managed Redis page and in the Key Value guide. Our Redis job queue guide explains why a queue needs a store that does not evict keys, which matters whichever host you choose.

FAQ

How much does ElastiCache cost per month in India? The smallest Mumbai node, cache.t4g.micro on Valkey, is about Rs 1,097 per month before GST. A serverless Valkey cache starts at about Rs 370 per month. A production pair with failover on cache.t4g.small is about Rs 4,498.

Is ElastiCache Valkey cheaper than Redis? Yes. In Mumbai, Valkey nodes cost 20% less, serverless storage 33% less and requests 32% less, and the serverless minimum is 100 MB instead of 1 GB.

Does ElastiCache charge GST in India? Accounts billed by AWS India are invoiced in rupees with 18% GST added.

Is ElastiCache serverless cheaper than nodes? For small or spiky caches, usually yes, especially on Valkey. For a cache holding several GB all day, nodes are usually cheaper.

Can I connect to ElastiCache from outside AWS? Not directly. It is reached from inside your AWS network, so an app hosted elsewhere needs extra networking to connect.

Is there an ElastiCache free tier in 2026? New accounts get up to $200 in AWS credits for up to 6 months instead of a permanent free tier.

Prices from AWS’s Mumbai price list published 28 October 2026; conversion at Rs 93.92 per US dollar (ECB reference rate, 6 November 2026). Prices change; check the AWS page before you commit. Found something out of date? Write to support@getvoroa.com.

This page compares free Redis hosting the way you would actually use it: as a cache, a session store or a job queue behind an app that has to keep working. We run a Redis-compatible store in Mumbai, so we did not only read pricing pages. Every limit below was checked against the provider’s own documentation on 7 November 2026, and every latency number was measured by us on the same day, from a home broadband connection in India and from a server in Mumbai.

On this page

• Which free tier fits which job
• Free Redis hosting compared: 8 options
• Latency from India, measured
• Why a far-away cache is worse than no cache
• Four ways a free key value store lets you down
• What 500,000 commands a month really buys
• Is Redis free? The licence change and Valkey
• Create a free key value store in Mumbai on Voroa
• FAQ

Which free tier fits which job

• Learning Redis commands, or a weekend project: Redis Cloud. It is the official service, the console is good, and 30 MB is plenty to learn on. Use it at least once every 14 days or it is deleted.
• A serverless app (Vercel, Netlify, edge functions): Upstash. It answers over HTTP as well as the Redis protocol, so a function does not have to hold a connection open. Watch the 500,000 commands a month.
• A cache you can afford to lose: Render’s free Key Value, if your app is also on Render. It keeps nothing on disk, so every restart empties it.
• Sessions or a queue that must survive a restart: pick a tier that writes to disk. Upstash, Aiven, Layerbase and Voroa do; Render’s free tier does not.
• Your app runs in India: put the store in Mumbai, next to the app. From a server in Mumbai we measured about 9 ms to Mumbai and about 86 ms to Singapore, per round trip.

Free Redis hosting compared: 8 options

Every option we could verify, with limits as published by each provider on 7 November 2026. Sources: Upstash pricing and FAQ, Redis Cloud Essentials plans, the Redis Cloud inactivity policy, Aiven’s free plan page, Render free instances, Railway’s trial terms, Layerbase’s plan page, the AWS Free Tier page, and Voroa free instances.

Three notes on the table. Aiven, Render and Voroa run Valkey or a Redis-compatible engine rather than Redis Ltd’s own build; your client library does not notice the difference for everyday commands. AWS needs a payment card at sign-up and its free period ends. Upstash also hands out an unclaimed database through a single HTTP request with no sign-up, but that one is deleted after 3 days unless you claim it into an account.

Latency from India, measured

We timed TCP connections to each region, 15 attempts each, and report the median. A TCP connect is one network round trip, which is the floor for every command you send. For Render we timed its public key value endpoints. Upstash, Redis Cloud and ElastiCache all run their Mumbai and Singapore databases inside AWS, so for those we timed the AWS regional endpoints as the baseline; we assume a database in the same region adds little to it, but we did not measure each provider’s own endpoint. For Voroa we timed the public address of our Mumbai database host on port 443.

From a home broadband connection in India

From a server in Mumbai (where your app runs, if you host it in India)

An app on Voroa does not go out to the internet to reach its key value store at all. It connects over the private network inside the Mumbai region, using the internal address on the database page.

Why a far-away cache is worse than no cache

You add Redis to make a request faster. Whether it does depends almost entirely on distance.

A cache read is one round trip. A query against a Postgres database next to your app is also roughly one round trip plus a few milliseconds of work. If the database is in Mumbai and the cache is in Singapore, the “fast” path is now 86 ms and the “slow” path is about 10 ms. The cache made the page slower, and every cache miss pays for both trips.

It adds up because a request rarely sends one command. A typical page checks the session, reads a rate limit counter, increments it and reads one cached fragment. Four commands sent one after another cost about 36 ms with the store in Mumbai and about 344 ms with it in Singapore, before your code has done anything.

Two habits help wherever the store is:

• Pipeline. Send several commands in one round trip. Most clients support it; in redis-py it is r.pipeline(), in ioredis it is redis.pipeline().
• Keep connections open. A new TLS connection costs several round trips before the first command. A long-running server opens its connections once. A serverless function that connects on every call should use an HTTP-based client, which is exactly what Upstash’s REST API is for.

The real rule is simpler than either habit: put the cache in the same region as the app.

Four ways a free key value store lets you down

Free tiers fail in one of four ways. Knowing which one applies tells you more than the memory figure.

1. It forgets. Render’s free Key Value keeps everything in memory only. Render can restart it for maintenance at any time, and when it does, every key is gone. Upgrading to a paid plan also loses the data. That is fine for a cache your app can rebuild, and wrong for sessions: every restart logs out every user.

2. It sleeps. Layerbase hibernates a free database after 15 minutes without connections. The next connection wakes it in roughly 1 to 5 seconds. Nothing is lost; the first request after a quiet spell waits.

3. It hits a wall. Each tier has a hard number that changes behaviour without warning your users:

• Memory. When a store is full it either refuses writes with OOM command not allowed when used memory > 'maxmemory', or evicts keys to make room, depending on its eviction policy. Check which one you have. Evicting is right for a cache and wrong for a queue.
• Commands. Upstash’s free tier allows 500,000 commands a month (the maths is below).
• Throughput. Redis Cloud’s free database is capped at 100 operations per second.
• Connections. Redis Cloud allows 30, Layerbase 20. A web server with a pool of 10, a worker and a scheduler can reach that sooner than you expect, and the next client gets ERR max number of clients reached.

4. It goes when idle. Redis Cloud deletes a free database after 14 days in which no command reaches it. Logging in to the console does not count. There is no backup, so the data is gone. Upstash archives a free database after at least 30 days of inactivity and lets you restore it. Layerbase archives a database after 14 days hibernated and reclaims it after 90 days archived. Aiven does not delete a free service, but powers it off when it is not being used, after a notice by email. If your project is quiet for a fortnight, these are the tiers that bite.

What 500,000 commands a month really buys

Half a million sounds like a lot. Spread over a month it is about 16,700 commands a day, or 11 a minute.

What uses commands is often not your users:

• A queue worker that polls once a second sends 2.6 million commands a month on its own, five times the free allowance.
• A health check that pings the store every 10 seconds uses about 260,000 a month.
• A page that sends four commands per view runs out at around 125,000 page views a month.

If a background worker is part of your design, a tier that meters commands is the wrong fit, however much memory it has. Pick one that limits memory and connections instead, and pair the store with a background worker in the same region so the polling never leaves the data centre.

Is Redis free? The licence change and Valkey

Is Redis free? Yes, to use. Redis 8 and later is offered under a choice of three licences, one of which is the AGPLv3, an open source licence. You can run it, build a product on it and charge for that product without paying Redis Ltd. What changed is the licence for companies that sell Redis itself as a hosted service.

The history, from the official Redis licence page:

Is Redis free for commercial use? Using Redis inside your own application, commercial or not, has been free under every one of those licences. The restrictions in RSALv2 and SSPLv1 are aimed at offering Redis to others as a managed service.

What is Valkey? When Redis moved away from BSD in 2024, a group of contributors forked the last BSD version and started Valkey under the Linux Foundation. Valkey stays BSD-licensed and speaks the same protocol, so the same client libraries work against it. Many hosts, including several on this list, now run Valkey under a “Redis-compatible” label.

For your app, the practical answer is the same as for Postgres: the software costs nothing, the machine it runs on does. A free tier is a provider paying for a small machine on your behalf, and the catches above are how they keep that cost bounded.

Create a free key value store in Mumbai on Voroa

Voroa’s free plan includes one managed key value store per account: 128 MB of RAM, up to 50 connections, in Mumbai, with no card. It writes your data to disk and takes a nightly snapshot, so a restart does not start from empty.

The trade-offs are real. 128 MB is small, so it suits sessions, rate limits and a modest cache rather than a large dataset. Free services and free databases in a workspace share 750 running hours a month; a free store on its own uses about 744, but a free store plus a free web service running all month use them up in about 16 days, after which free services stop until the 1st. And free database capacity is shared across the platform, so if it is full, a new free store is refused with a clear message instead of being queued. The free tier rules list every limit.

Step 1. In the dashboard select New, then Key Value.

Step 2. Name it and pick the free size. Under When memory is full, keep Keep everything if every key matters, or choose a drop option if the store is only a cache.

Step 3. Copy the connection URL shown at create time. It is shown once.

Step 4. Add it to your service as an environment variable, for example REDIS_URL.

Step 5. Point your existing client at it. No other code change is needed:

// Node.js, with the redis package
import { createClient } from 'redis';
const client = createClient({ url: process.env.REDIS_URL });
await client.connect();
await client.set('greeting', 'namaste', { EX: 60 });

# Python, with redis-py
import os, redis
r = redis.from_url(os.environ["REDIS_URL"])
r.set("greeting", "namaste", ex=60)

To reach it from your laptop or an app hosted elsewhere, turn on external access on the database page and you get a TLS (rediss://) endpoint. What each setting does, including the read-only Data tab for browsing keys, is in the Key Value guide. Moving data in from another host is covered in importing an existing database.

FAQ

Is there a completely free Redis server online? Yes. Upstash, Redis Cloud, Aiven, Render, Layerbase and Voroa all offer a free tier with no end date. Each has a catch: a command allowance, deletion when idle, a power-off, no persistence, hibernation or a small memory size.

Which free Redis cloud tier does not delete my data when I am away? Render and Voroa have no inactivity deletion today, and Aiven only powers a quiet service off. Upstash archives after 30 days and lets you restore. Layerbase archives after 14 days hibernated and reclaims the database after 90 days archived. Redis Cloud deletes a free database after 14 days without commands, with no backup.

Can I get free Redis hosted in India? Upstash, Redis Cloud and Voroa let you put a free database in Mumbai. AWS Mumbai is free only during its credit-based trial. Render and Railway are closest in Singapore, and Aiven does not let you pick a region on its free plan.

Which free tier keeps data after a restart? Upstash, Aiven, Layerbase and Voroa write to disk. Render’s free Key Value does not. Redis Cloud’s free database has no backups, so a deleted free database cannot be recovered.

Is the Redis free tier enough for sessions in production? For a small app, often yes, if the store keeps data on disk and sits next to your app. Size it for your active sessions, not your total users, and give sessions an expiry so old ones clear themselves.

What should I use instead of Redis for permanent data? A real database. Redis keeps data in memory, and even with disk persistence the last moments before a crash can be lost. Keep what you cannot rebuild in Postgres; our free Postgres comparison covers the same ground for databases.

Get a free key value store in Mumbai

One free store per account, 128 MB, no card, kept on disk, in Mumbai. See every size and what it costs on the managed Redis page.

Last updated: 7 November 2026. We re-check every limit and re-run every measurement monthly. If a provider has changed something we missed, write to support@getvoroa.com and we will correct it.

This guide explains how it works, the limits that matter, and how the common alternatives compare. Every platform fact below comes from that platform’s own documentation, checked on 7 November 2026.

On this page

• How the add-on works
• The five limits that matter
• What it costs
• The clock process: Heroku’s own alternative
• How other platforms schedule jobs
• Moving a scheduled job off Heroku
• FAQ

How the add-on works

You add it from the Resources tab or with one command:

heroku addons:create scheduler:standard

Then, in its dashboard, you enter a command such as rake send_digest or python manage.py cleanup, pick a frequency and a dyno size, and set the next run time.

At each run, Heroku starts a one-off dyno, runs your command in it, and shuts it down. It is the same as typing heroku run your-command, so if a command works with heroku run, it will work here.

The five limits that matter

1. Only three frequencies. Every 10 minutes, every hour, or every day. There is no cron expression, so “weekdays at 9 am” or “every 5 minutes” cannot be set directly.

2. Times are in UTC. A daily job set for 03:30 runs at 9:00 am in India. Add the offset yourself when you pick the time.

3. Runs are best-effort. Heroku says job execution is “expected but not guaranteed”. In very rare cases a job may be skipped, and in very rare cases it may run twice. Heroku recommends a clock process for critical production jobs.

4. Each run is a fresh dyno. Nothing you write to disk survives between runs, and start-up time is part of every run. That is good for isolation and bad for very frequent, very short jobs.

5. A run is killed at its interval. Heroku says a scheduler dyno will not run longer than its scheduling interval: a 10-minute job is stopped after about 10 minutes, an hourly job after about an hour. Because of timing jitter, two runs of the same job may briefly overlap.

What it costs

The add-on itself is free. The one-off dynos it starts are billed like any other dyno usage, and they appear on your invoice as a “scheduler” dyno type.

So the cost depends on how long each run lasts and how often it runs. A two-minute job every 10 minutes is about 288 minutes of dyno time a day, about 144 hours a month. A two-minute daily job is about one hour a month.

The clock process: Heroku’s own alternative

For jobs that must run, Heroku points to a custom clock process: a small process in your Procfile that runs all the time and decides when jobs are due.

web:    node web.js
worker: node worker.js
clock:  node clock.js

It gives you full cron expressions and your own timezone. The trade-offs, from Heroku’s guidance:

• It runs 24/7, so you pay for a dyno all month.
• Run exactly one clock dyno. Scaling it to two schedules every job twice.
• Dynos restart at least once a day, so the clock needs start-up logic to catch runs it missed.

That duplicate-run warning is real. We measured it for in-process schedulers: two processes ran every job twice, in both Node.js and Python.

How other platforms schedule jobs

Each platform handles the three hard questions differently: how often, what happens if a run is still going, and which timezone.

Sources: Heroku Scheduler and clock process docs, the Render cron job docs, the Railway cron docs and the GitHub Actions schedule docs, all checked on 7 November 2026.

Three things stand out. Railway requires your process to exit after each run. Render guarantees only one run at a time by delaying the next. And every hosted scheduler here except Voroa schedules in UTC by default, which matters if your users are in India.

Moving a scheduled job off Heroku

1. List your jobs. Copy each command, its frequency and its next run time from the Scheduler dashboard.
2. Convert to cron. “Every 10 minutes” is */10 * * * *, “every hour at :30” is 30 * * * *, “daily at 03:30 UTC” is 30 3 * * *. Our guide to cron every 5 minutes has more patterns.
3. Fix the timezone. If the new platform uses IST, a daily 03:30 UTC job becomes 0 9 * * *.
4. Make jobs safe to run twice. Every platform above can, in some case, run late, overlap or repeat.
5. Check the effect, not just the log. After the first run, confirm the rows were written or the email went out.

On Voroa, create a Cron Job from your repository with the same command and the converted schedule, and add your environment variables. Runs are skipped while the service is stopped, including after a free workspace uses its monthly free hours, until the 1st.

Steps are in scheduling a task on Voroa, and worker or cron job helps if your job is really a long-running process. More on running workers is on the background workers page.

FAQ

Is Heroku Scheduler free? The add-on is free, but each run uses a one-off dyno, and that dyno time is billed like other dyno usage.

What is the minimum interval for Heroku Scheduler? Every 10 minutes. The other choices are hourly and daily. It does not accept cron expressions.

What timezone does Heroku Scheduler use? UTC. Subtract 5 hours 30 minutes from the Indian time you want.

Is Heroku Scheduler reliable? Heroku describes runs as expected but not guaranteed: very rarely a job is skipped or runs twice. For critical jobs it recommends a clock process.

How do I run a Heroku job every 5 minutes? Not with Scheduler. Use a clock process with a cron library, or a platform that accepts cron expressions.

What is the best Heroku Scheduler alternative? It depends on your stack. Pick one that accepts full cron expressions, states what happens to overlapping runs, and schedules in the timezone your users live in.

Checked 7 November 2026 against each platform’s documentation. Found something out of date? Write to support@getvoroa.com.

On this page

• What Pub/Sub is, in one paragraph
• The commands, with working code
• Test 1: a subscriber goes offline
• Test 2: one message, a hundred listeners
• Test 3: the subscriber that cannot keep up
• Pub/Sub, Streams or a job queue?
• What it is good at
• Running it on a managed store
• FAQ

What Pub/Sub is, in one paragraph

A publisher sends a message to a channel with PUBLISH. Every client subscribed to that channel at that moment receives it. Redis does not store the message anywhere: if nobody is listening, it is gone, and PUBLISH tells you how many clients received it. The official documentation calls this at-most-once delivery: a message arrives once, or not at all.

The commands, with working code

Over the RESP2 protocol, which most clients use by default, a connection that has subscribed can only run subscription commands, so a client needs a separate connection for its normal reads and writes.

Node.js (with ioredis):

import Redis from 'ioredis';

const sub = new Redis(process.env.REDIS_URL);   // subscribe-only connection
const pub = new Redis(process.env.REDIS_URL);   // normal connection

await sub.subscribe('orders');
sub.on('message', (channel, message) => {
  const order = JSON.parse(message);
  console.log('new order', order.id);
});

const receivers = await pub.publish('orders', JSON.stringify({ id: 42 }));
console.log('delivered to', receivers, 'subscribers');

Python (with redis-py):

import os, json, redis

r = redis.from_url(os.environ["REDIS_URL"])
p = r.pubsub()
p.subscribe("orders")

r.publish("orders", json.dumps({"id": 42}))

for msg in p.listen():
    if msg["type"] == "message":
        print("new order", json.loads(msg["data"])["id"])

Test 1: a subscriber goes offline

Setup for all three tests: Redis 8.10.3 in a Linux virtual machine (WSL2) on a laptop, with a Node.js 24 client using ioredis on the same laptop. Default configuration. Measured 7 November 2026.

We connected a subscriber and published 100 messages: it received all 100. Then we disconnected it, published 100 more, and reconnected.

This is the single most important fact about Pub/Sub. A deploy, a network blip, or a client reconnecting after a Redis restart all create a gap, and every message published in that gap is lost for good. If a missed message means a missed payment, a missed email or an order nobody sees, Pub/Sub is the wrong tool. Use a Redis job queue or Streams instead.

The return value of PUBLISH is your only signal. If it is 0 when you expected listeners, log it.

Test 2: one message, a hundred listeners

We published 1,000 messages to 1, 10 and 100 subscribers, each message carrying the time it was sent, and measured how long each one took to arrive.

Every message reached every subscriber. Delivery time grew with the number of listeners, but read this table carefully: all our subscribers ran inside one Node.js process, so the higher numbers include our own client working through 100 connections one by one. We expect, but did not measure, that subscribers spread across separate processes or servers would each see something closer to the single-subscriber figure, plus the one-way network time from Redis.

Raw throughput is high. Publishing 100,000 small messages in a pipeline to one subscriber, all of them arrived in 664 ms, about 150,000 messages a second.

Test 3: the subscriber that cannot keep up

This one is rarely tested, and it causes real outages. Redis buffers outgoing messages for each subscriber. If a subscriber reads more slowly than messages arrive, its buffer grows. Redis protects itself with a limit, and the default for Pub/Sub clients is pubsub 32mb 8mb 60: disconnect the client if its buffer passes 32 MB, or stays above 8 MB for 60 seconds. We confirmed both Redis 8.10.3 and Valkey 9.1.3 ship with that default.

We subscribed with a client that stopped reading its socket, then published 1 KB messages as fast as we could.

Redis closed the subscriber’s connection. A normal client such as ioredis sees that close, reconnects and subscribes again, so from the outside it looks healthy. But everything that was sitting in the 32 MB buffer, and everything published while it reconnected, is lost, exactly as in Test 1. In production this looks like “live updates stop working under load”, and the cause is a subscriber doing slow work, such as a database write, inside its message handler.

Two habits prevent it:

• Do almost nothing in the handler. Push the message onto an in-process queue or a job queue and return. Never wait on a database or an API inside on('message').
• Watch the counter. client_output_buffer_limit_disconnections going up means a subscriber is being cut off. See the client output buffer settings in the Redis documentation.

Pub/Sub, Streams or a job queue?

The rule of thumb: Pub/Sub for things that only matter right now, Streams for events you might need to replay, a job queue for work that must happen even if it occasionally runs twice.

What it is good at

• WebSocket fan-out across servers. When you run two or more instances of a chat or live-dashboard app, a message received by one instance has to reach users connected to the others. Socket.IO’s Redis adapter does exactly this with Pub/Sub.
• Cache invalidation. When one service updates a record, it publishes the key, and every instance drops its in-memory copy. A missed message only means one stale cache entry until its expiry.
• Live progress. A worker publishes “50% done” and the web server pushes it to the browser. If one update is lost, the next one replaces it.
• Keyspace notifications. Redis can publish an event when a key expires or changes, which is useful for light-weight triggers. They are off by default (notify-keyspace-events), a managed host may not let you turn them on, and they are fire-and-forget too, so do not build billing on them.

In every one of these, losing an occasional message is harmless. That is the test to apply.

Running it on a managed store

Count your connections. Every subscriber holds a connection open for as long as it listens, and it needs a second one for normal commands. Ten app instances with one subscriber and one normal connection each use 20 connections before any job queue or admin tool. Check your plan’s connection limit; Voroa’s free key value size allows 50, and paid sizes from the Rs 425 one upward allow 250 or more.

Keep subscribers close. Pub/Sub delivery is one network hop from Redis to each subscriber. From a server in Mumbai we measured about 9 ms to a Mumbai region and about 86 ms to Singapore, per round trip; the numbers are in our free Redis hosting comparison. Put the store in the same region as the app.

Expect reconnects. A managed store restarts for maintenance and upgrades. ioredis resubscribes automatically after a reconnect by default; check how your own client behaves. Either way, messages sent during the gap are gone, as Test 1 showed.

Engine choice does not matter here. Pub/Sub is part of the core both engines share, and we confirmed Valkey 9.1.3 ships the same buffer default; our tests themselves ran on Redis. See Valkey vs Redis for where they do differ.

On Voroa, your web services and background workers reach a key value store over the private network in Mumbai, using the connection URL you add as an environment variable. Setup details are in the Key Value guide.

FAQ

Does Redis store Pub/Sub messages? No. A message goes only to clients subscribed at that moment. If none are, it is discarded and PUBLISH returns 0.

Is Redis Pub/Sub reliable? It is fast and simple, but delivery is at-most-once. In our tests, messages sent while a subscriber was offline were never delivered, and a subscriber that fell 32 MB behind was disconnected.

What is the difference between Redis Pub/Sub and Streams? Streams store messages, so a consumer can read what it missed, acknowledge messages and retry. Pub/Sub stores nothing.

How many subscribers can Redis Pub/Sub handle? Many; the practical limit is connections and network. In our test, 100 subscribers each received all 1,000 messages. Plan around your store’s connection limit.

Why does my subscriber stop receiving messages? Usually a reconnect gap or a slow handler that pushed its buffer past the limit. Check client_output_buffer_limit_disconnections in INFO stats.

Can I use Pub/Sub as a job queue? No. A job published while no worker is listening is lost, and two workers would both run it. Use a queue library or Streams with a consumer group.

Add a key value store for live updates

A Redis-compatible store in Mumbai, next to the services you deploy, with a free size to start. See the sizes on the managed Redis page.

Tested 7 November 2026 on Redis 8.10.3 in WSL2 on a laptop; Valkey 9.1.3’s buffer default confirmed. Found something out of date? Write to support@getvoroa.com.

On this page

• What a stream is
• The six commands you need
• Consumer groups: sharing the work
• Tested: an offline consumer catches up
• Tested: a consumer crashes mid-job
• Tested: memory per entry and trimming
• Tested: read one at a time, or in batches?
• Streams, Pub/Sub, lists or Kafka?
• A worker loop you can copy
• FAQ

What a stream is

A stream is a key holding an ordered list of entries. Each entry has an ID, made of a millisecond timestamp and a sequence number such as 1762500000000-0, and a small set of field-value pairs. New entries go on the end. Entries stay until you trim them, so any consumer can read from any point.

The six commands you need

XGROUP CREATE orders billing 0 MKSTREAM creates the group reading from the oldest entry (and the stream, if it does not exist; use $ instead of 0 to start from new entries only), and XRANGE reads a range of history without a group. The full list is in the Redis Streams documentation.

Consumer groups: sharing the work

A consumer group is a named reader of the stream with its own position. Two things follow:

• Inside one group, each entry goes to one consumer. Run three billing workers and they split the entries between them, like a job queue.
• Each group sees every entry. A billing group and an analytics group both receive every order, independently, like Pub/Sub that remembers.

When a consumer reads an entry, it moves to that group’s pending list until the consumer acknowledges it with XACK. That pending list is what makes crash recovery possible.

Tested: an offline consumer catches up

Setup for all the tests: Redis 8.10.3 in a Linux virtual machine (WSL2) on a laptop, with a Node.js 24 client using ioredis on the same laptop. Default configuration. Measured 7 November 2026.

We created a group, added 100 entries while no consumer was running, then started a consumer.

Compare that with Pub/Sub, where the same test delivered 0 of 100 (see Redis Pub/Sub, tested). This is the main reason to choose Streams: a deploy or a crash does not lose events.

Tested: a consumer crashes mid-job

Consumer c1 read 10 entries and then “crashed” without acknowledging them.

Nothing was lost and nothing needed a manual fix. In production you would set the idle time to longer than your slowest job, for example 60 seconds, and run XAUTOCLAIM from every consumer on a timer.

Two things to plan for:

• An entry can be processed twice. If c1 finished the work but crashed before XACK, c2 repeats it. Make handlers idempotent: check whether the order was already charged before charging it.
• Poison entries. An entry that crashes every consumer is claimed again and again. The extended form XPENDING orders billing - + 100 shows a delivery count per entry; after, say, five attempts, copy it to a dead-letter stream and acknowledge it.

Tested: memory per entry and trimming

We added 100,000 entries with two short fields (user and action), then compared that with a plain list holding the same data as strings.

Streams are compact: entries that share the same field names are packed together, so the field names are not stored again for every entry. But a stream never shrinks on its own. XACK does not delete anything; acknowledged entries stay until you trim. An event stream with no trimming will eventually fill your store.

Trim on every write with MAXLEN ~ N (keep about N entries) or MINID ~ <id> (keep entries newer than a time). The ~ lets Redis trim in efficient chunks rather than to the exact number, which is much cheaper. In our test it kept 10,000 entries in 0.20 MB while 100,000 went through; usually ~ leaves slightly more than N, because it trims whole internal blocks.

At about 21 bytes per small entry, a 128 MB store holds a few million entries before anything else. Larger entries cost more; measure your own with MEMORY USAGE.

Tested: read one at a time, or in batches?

Reading in batches was about 100 times faster than reading one entry at a time, with Redis on the same laptop. Each single read costs a full round trip, so over a real network the gap only widens: at 9 ms per round trip (Mumbai to Mumbai, as measured in our free Redis hosting comparison) a one-at-a-time consumer would manage roughly 50 entries a second. Use COUNT of 50 to 500 and acknowledge the whole batch in one XACK.

Streams, Pub/Sub, lists or Kafka?

Pick Streams when you already run Redis and need durable events with a few consumer groups. Pick a dedicated broker such as Kafka when the event log is the centre of your system, needs to be kept for weeks and is read by many teams. For background jobs with retries and delays, a queue library is less work; see our Redis job queue guide.

A worker loop you can copy

import Redis from 'ioredis';
const r = new Redis(process.env.REDIS_URL);
const STREAM = 'orders', GROUP = 'billing', ME = `c-${process.pid}`;

// '0' = start from the oldest entry, so nothing written before the first worker is missed
await r.xgroup('CREATE', STREAM, GROUP, '0', 'MKSTREAM').catch((e) => {
  if (!String(e.message).includes('BUSYGROUP')) throw e;           // only "group exists" is fine
});

async function handle(id, fields) { /* your idempotent work */ }

for (;;) {
  // 1. take over anything a crashed consumer left behind for over 60 s
  const [, stale] = await r.xautoclaim(STREAM, GROUP, ME, 60000, '0', 'COUNT', 100);
  // 2. read new entries in a batch, waiting up to 5 s
  const res = await r.xreadgroup('GROUP', GROUP, ME, 'COUNT', 200, 'BLOCK', 5000, 'STREAMS', STREAM, '>');
  const entries = [...stale, ...(res ? res[0][1] : [])];
  // (production: check delivery counts with XPENDING STREAM GROUP - + 100 and move entries
  //  delivered 5+ times to a dead-letter stream before handling them)
  for (const [id, fields] of entries) await handle(id, fields);
  if (entries.length) await r.xack(STREAM, GROUP, ...entries.map(([id]) => id));
}

Producers trim as they write:

await r.xadd('orders', 'MAXLEN', '~', 100000, '*', 'id', '42', 'total', '499');

Run the loop as a long-running process, separate from your web server. On Voroa that is a background worker, which never sleeps, next to a key value store in the same Mumbai region; the store’s connection URL goes in an environment variable. Store details are in the Key Value guide.

Run Streams next to your workers

Voroa runs a Redis-compatible key value store in Mumbai beside the services and background workers you deploy, with data written to disk and a free size to start. See the sizes on the managed Redis page.

FAQ

What is the difference between Redis Streams and Pub/Sub? Streams store entries, so a consumer that was offline can catch up, and entries can be acknowledged and retried. Pub/Sub stores nothing. In our tests, Streams delivered 100 of 100 entries to a late consumer; Pub/Sub delivered 0.

Does XACK delete the entry? No. It only removes the entry from the group’s pending list. Trim the stream with MAXLEN or MINID to free memory.

How many consumers can a group have? As many as you like. Each entry goes to one consumer in the group, so adding consumers spreads the load.

Are Redis Streams durable? They are as durable as your Redis persistence. With data written to disk, entries survive a restart, except possibly the last moments before a crash; on a store with no persistence, a restart loses the stream.

Can Redis Streams replace Kafka? For modest volumes and a handful of consumer groups, often yes, and you avoid running another system. For long retention, very high throughput or many teams reading the same log, a dedicated broker fits better.

Do Streams work in Valkey? Yes. Streams are part of the core that Valkey kept from Redis 7.2. See Valkey vs Redis for where the two differ.

Tested 7 November 2026 with Redis 8.10.3 in WSL2 on a laptop. Found something out of date? Write to support@getvoroa.com.

On this page

• The commands
• What TTL returns: -1 and -2
• The SET that deletes your expiry
• How expiry actually happens
• Tested: how fast expired keys free memory
• Expiring one field of a hash
• Expiry and a full store
• Four patterns worth copying
• FAQ

The commands

The full reference is in the EXPIRE documentation.

What TTL returns: -1 and -2

Setup for every test on this page: Redis 8.10.3 in a Linux virtual machine (WSL2) on a laptop, with a Node.js 24 client using ioredis. Default configuration. Measured 7 November 2026.

So -1 means “this key will never expire”, which is often a bug in a cache, and -2 means “it is gone”. Check for both explicitly; treating any negative number as “expired” hides the -1 case.

The SET that deletes your expiry

This is a common cause of “my cache never expires” and “my store is full of old sessions”. A plain SET on a key that already has an expiry removes the expiry.

Commands that change a value in place, such as INCR, APPEND, HSET or LPUSH, keep the expiry. SET replaces the whole value and clears the expiry unless you pass EX, PX or KEEPTTL. GETSET always clears it; use SET key value GET KEEPTTL instead. The safe habit: every SET on an expiring key carries its own EX, or KEEPTTL if you mean to keep the old one.

// wrong: the session silently becomes permanent
await redis.set(`sess:${id}`, JSON.stringify(session));

// right: refresh the full lifetime, or keep the remaining one
await redis.set(`sess:${id}`, JSON.stringify(session), 'EX', 1800);
await redis.set(`sess:${id}`, JSON.stringify(session), 'KEEPTTL');

How expiry actually happens

Redis does not delete a key the instant its time is up. It uses two methods together:

1. On access. When you read a key whose time has passed, Redis deletes it there and then and answers as if it never existed. You never get an expired value back.
2. In the background. Several times a second, Redis samples keys that have an expiry and deletes the expired ones it finds. It keeps going while it keeps finding many, so a large batch of expired keys is cleared quickly.

The result is that expired keys are invisible to your app immediately, but can take a moment to leave memory, and DBSIZE may briefly count keys that have already expired.

Tested: how fast expired keys free memory

All keys expiring together. We wrote 200,000 keys with 100-byte values and a 2-second expiry (36.9 MB), then watched.

Some keys had expired during the load itself. Within 2.5 seconds of the last write, every key and every byte was gone, without any reads. When most keys in a store are expired, the background cleanup finds them fast.

Expiring keys mixed with long-lived ones. We then wrote 200,000 keys where every second key expired after 2 seconds and the rest after an hour, so 100,000 should remain.

Here the cleanup slowed down: after 10 seconds about 1.5% of the expired keys were still in memory, because random samples now mostly hit keys that are not due. They are still invisible to your app, and a read deletes them on the spot. The practical lesson is small but real: on a nearly full store, do not count on expired keys freeing their memory instantly.

Expiring one field of a hash

Until recently an expiry applied to a whole key. Redis 7.4 added field-level expiry for hashes, and Valkey 9.0 added the same commands.

HSET user:1 name Asha otp 482913
HEXPIRE user:1 2 FIELDS 1 otp      -> 1  (expiry set)
# 2.5 seconds later
HGETALL user:1                     -> name: Asha   (otp is gone)

We tested exactly that: after 2.5 seconds the otp field had disappeared and name remained. It is a neat fit for one-time codes, per-device tokens or feature flags stored on a user record. Check that your host’s engine version supports it before you rely on it.

Expiry and a full store

Expiry and eviction are different things. Expiry deletes keys whose time is up. Eviction deletes keys early because memory is full, and only if the store is configured to do so.

• With a no-eviction setting, a full store refuses new writes. Expiries are then your main way of making room, so every cache key should have one.
• The volatile eviction policies (volatile-lru, volatile-ttl and others) only ever evict keys that have an expiry. If none of your keys have one, those policies behave like no-eviction.
• The allkeys policies evict any key, expiry or not.

On Voroa, a key value store’s When memory is full setting defaults to Keep everything, which refuses writes when full, and you can switch it to a drop option for a pure cache. On the 128 MB free size, consistent expiries are what keep a cache from filling up. The setting is explained in the Key Value guide.

Four patterns worth copying

Sliding session expiry. Reset the lifetime on every request, in one command:

const session = await redis.getex(`sess:${id}`, 'EX', 1800); // read and extend to 30 min

Fixed-window rate limit. Count requests and start the window only on the first one:

// Redis 7+: count and set the window in one atomic transaction
const [[, n]] = await redis.multi()
  .incr(`rl:${ip}`)
  .expire(`rl:${ip}`, 60, 'NX')      // only starts the window; never extends it
  .exec();
if (n > 100) return res.status(429).end();

On older versions you will see INCR followed by EXPIRE only when the count is 1. That works until the process dies between the two calls: the counter then never expires, and that user is blocked for good. On a version before 7, do the increment and the first expiry together in a short Lua script instead.

Cache with jitter. Add a few random seconds so thousands of keys written together do not all expire in the same second and send every request to your database at once:

const ttl = 300 + Math.floor(Math.random() * 60);
await redis.set(`cache:${key}`, value, 'EX', ttl);

One-time codes. Store the code with a short expiry and delete it on use:

await redis.set(`otp:${phone}`, code, 'EX', 300);
// on verify
const ok = (await redis.getdel(`otp:${phone}`)) === submitted;

If you run cleanup work on a timer instead, such as a nightly purge of old records in your database, a scheduled task is the right tool; let Redis handle expiry for its own keys. Jobs that must run later are a job queue’s delayed jobs, covered in our Redis job queue guide.

Run it next to your app

Voroa runs a Redis-compatible key value store in Mumbai beside the web services you deploy, with a free size to start; the connection URL goes in an environment variable. See the sizes on the managed Redis page.

FAQ

What does TTL -1 mean in Redis? The key exists and has no expiry, so it will never be deleted on its own. A plain SET on an expiring key is a common cause.

What does TTL -2 mean? The key does not exist, either because it was never set or because it has expired.

Does SET remove the TTL? Yes. SET without EX, PX or KEEPTTL clears any existing expiry. INCR, HSET, LPUSH and similar in-place changes keep it.

Are expired keys deleted immediately? They become invisible immediately and are deleted when accessed or by background cleanup. In our test, 200,000 keys expiring together were gone from memory within 2.5 seconds; when mixed with long-lived keys, about 1.5% lingered after 10 seconds.

Can I set a TTL on one field of a hash? Yes, with HEXPIRE on Redis 7.4 and later or Valkey 9.0 and later.

What is the maximum TTL? Expiry times are stored as millisecond Unix timestamps, so in practice any lifetime you need works. For “forever”, do not set an expiry at all.

Tested 7 November 2026 with Redis 8.10.3 in WSL2 on a laptop. Found something out of date? Write to support@getvoroa.com.

On this page

• Two ways to store vectors in Redis
• Vector sets in five commands
• What we measured
• Quantization: the setting that decides memory
• How many vectors fit in your store
• Filtering results by attributes
• Redis or pgvector?
• Before you go to production
• FAQ

Two ways to store vectors in Redis

Vector sets are the simplest way in, and they are what we tested. The rest of this guide uses them.

Vector sets in five commands

VADD docs VALUES 3 0.12 0.48 0.31 doc:1        add a vector named doc:1
VSIM docs VALUES 3 0.10 0.50 0.30 COUNT 5      the 5 most similar
VSIM docs ELE doc:1 COUNT 5                    neighbours of an existing item
VREM docs doc:1                                remove one
VINFO docs                                     dimensions, size, quantization

From Node.js with ioredis, sending vectors as binary float32 is faster than text:

import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);
const f32 = (arr) => Buffer.from(new Float32Array(arr).buffer);

// store: embedding is an array of numbers from your model, e.g. 384 or 1536 long
await redis.call('VADD', 'docs', 'FP32', f32(embedding), `doc:${id}`);

// search: the 10 closest items to a query embedding
const ids = await redis.call('VSIM', 'docs', 'FP32', f32(queryEmbedding), 'COUNT', 10);

Vector sets compare by cosine similarity, so normalised embeddings from common text models work as they come.

What we measured

Setup. Redis 8.10.3 built from source, in a Linux virtual machine (WSL2) on a laptop, with a Node.js 24 client on the same laptop. We generated 20,000 synthetic 384-dimension vectors, a common size for small sentence-embedding models, grouped around 200 centres so that they behave more like real topics than pure noise, plus 200 query vectors from the same distribution. For each storage format we inserted all 20,000 in pipelined batches, ran the 200 queries one at a time asking for the 10 nearest, and compared each answer with an exact brute-force search. Measured 7 November 2026.

What we found.

1. The default is the right default. 8-bit storage halved memory against full precision and still returned 98.7% of the exact top-10 results, while inserting more than twice as fast.
2. Binary is a trap for this kind of data. It saved almost another third of the memory but found only 36% of the true neighbours. It can suit models designed for binary embeddings; test before you use it.
3. Queries were about a millisecond. All three formats answered in 1 to 2 ms at the median on 20,000 vectors. Most of a real request’s time will be spent creating the query embedding, not searching.
4. The index costs extra. A raw 384-dimension float32 vector is 1,536 bytes; full precision used 2,295 bytes per vector, the difference being the graph that makes search fast.

Synthetic data is kinder or harsher than your own depending on the model, so treat the recall figures as a guide and check recall on a sample of your real queries.

Quantization: the setting that decides memory

Quantization stores each number with fewer bits. VADD uses 8-bit by default, which you can confirm with VINFO (it reports quant-type int8). Use NOQUANT only if your results must match an exact search as closely as possible, and BIN only if your embedding model is designed for it. The choice is made when the first vector is added to a key, so decide before you load data. The full option list is in the vector sets documentation.

How many vectors fit in your store

Plain division of the space by the measured size per vector, before attributes and headroom (1 MB = 1,048,576 bytes):

The 1,536-dimension column is our estimate: in our test about 384 bytes of each 8-bit vector was the vector itself and about 760 bytes the index, so we scaled only the vector part by four, to about 2.3 KB. Measure your own. Remember that a managed store’s advertised size is not all available for data. On Voroa, for example, up to 40% of each instance can be held back for the nightly save, so a 1 GB store has about 600 MB for data.

Filtering results by attributes

Real searches usually need a filter: only this user’s documents, only products in stock. Vector sets let you attach a small JSON object to each item and filter on it during the search:

VSETATTR docs doc:1 '{"lang":"hi","year":2026}'
VSIM docs VALUES 3 0.10 0.50 0.30 COUNT 5 FILTER '.lang == "hi" and .year >= 2025'

Filtering works best when many items match. If a filter keeps only a tiny fraction of the set, results can come back slower or fewer than you asked for, because the search walks past many non-matching items. For heavily filtered search, the query engine or a database with proper indexes is a better fit.

Redis or pgvector?

Both are reasonable. The question is where the rest of your data lives.

Choose Redis when you need very low latency and the vector set is a cache or a derived index you can rebuild. Choose pgvector when vectors sit beside your business data and you want SQL filters, transactions and backups in one place. We covered that route in Postgres as a vector database.

Before you go to production

• Check your engine version. Vector sets need Redis 8 or later. Valkey does not have them; it offers vector search through its separate search module. See Valkey vs Redis.
• Plan for rebuilds. Keep the source text and model version in your database, so you can re-embed and reload when you change models. Vectors from different models cannot be mixed in one set.
• Persistence. Vectors held only in memory are lost on a restart without persistence; re-embedding everything is slow and costs API money. Use a store that writes to disk.
• Do not evict. A vector set is one key. An eviction policy that removes keys under memory pressure can delete your entire index at once. Use a no-eviction setting, and watch memory.
• Keep it close. Each search is a round trip; keep the store in the same region as the app that creates the query embedding.

Vector search on Voroa

Voroa’s key value store runs Redis 7.4 today, which does not have vector sets, so it is not the place for this. For vector search on Voroa, use managed PostgreSQL with the pgvector extension, which you can turn on from the database’s settings on a paid plan; the steps are in enabling PostgreSQL extensions. Your web services reach it over the private network in Mumbai. The key value store remains a good fit for caching the results of those searches; see the managed Redis page.

FAQ

Can Redis be used as a vector database? Yes. Redis 8 has vector sets for similarity search, and its query engine supports vector indexes inside hashes and JSON documents.

How much memory does a vector take in Redis? In our test, a 384-dimension vector took about 1,142 bytes with the default 8-bit format and 2,295 bytes at full precision, including the search index.

How accurate is Redis vector search? With the default format, 98.7% of the exact top-10 results in our test, and 100% at full precision. Binary storage dropped to 36% on our data.

Is Redis faster than pgvector? Redis answered our queries in about a millisecond from memory. pgvector can also be fast with an HNSW index, and it offers SQL filters and durability. Pick by where your data lives.

Does Valkey support vector sets? No. Valkey provides vector search through the valkey-search module, which uses a different set of commands.

What embedding size should I use? That is set by your model, for example 384 for small sentence models and 1,536 or more for larger ones. Memory grows roughly in proportion to the size.

Tested 7 November 2026 with Redis 8.10.3 in WSL2 on a laptop, using synthetic embeddings. Found something out of date? Write to support@getvoroa.com.

On this page

• Quick verdict for a new app
• Feature by feature
• We tested both on the same machine
• Threads: the argument that used to decide it
• What Memcached still does better
• What only Redis can do
• Which one to use
• Moving from Memcached to Redis
• FAQ

Quick verdict for a new app

For a new web app, use Redis (or Valkey). On a small server it is at least as fast as Memcached in our test, uses about the same memory for plain cached strings, and also gives you sessions that survive a restart, counters, queues and pub/sub from the same service. Choose Memcached only when you need a pure string cache on a large many-core machine, or your stack already depends on it.

Feature by feature

The pattern is clear: every feature Memcached has, Redis has too. The reverse is not true.

We tested both on the same machine

Most comparisons quote benchmarks from years ago, or none at all. We ran Redis 8.10.3 and Memcached 1.6.39, both built from source, side by side.

Setup. A Linux virtual machine (WSL2) on a 4-vCPU laptop. Each server got 2 CPU cores; Memcached ran 2 worker threads, Redis its default single command thread with persistence off. The same client, a small raw-socket program we wrote that speaks both protocols, ran on the other 2 cores with 50 connections against 100,000 keys holding 100-byte values. Five runs of 5 seconds each; we report the median. Measured 7 November 2026.

Memory for the same data

For plain cached strings the two are effectively the same. Memcached starts smaller, and grew by a few megabytes more while loading, because it hands out memory in fixed-size slabs.

Requests per second (2 server cores, 50 connections)

What we found.

1. Without pipelining, Redis was faster here, by about 60%, and the run ranges did not overlap. Read that with care: the client is our own program, it parses two different protocols, and we did not measure how much of the gap its parsing accounts for. Our guess is that on 2 cores, Memcached’s threads compete with each other for the same cores, but we did not prove it.
2. With pipelining, they tied. The ranges overlap, and at around 600,000 to 700,000 requests a second our single-threaded client is probably part of the limit for both.
3. Pipelining mattered far more than the choice of cache: about 8 to 14 times the throughput on both.

This is a small-machine test on purpose, because that is what most apps rent. It is not the whole story: Memcached’s design pays off when a server has many cores and thousands of clients, which this test does not cover. Treat the numbers as “what to expect on a small instance”, not a universal ranking.

Threads: the argument that used to decide it

The classic advice was “Memcached is multi-threaded, Redis is single-threaded, so Memcached scales better.” That was true and still partly is: Memcached spreads requests across all its threads, while Redis runs every command on one main thread.

Two things have changed. Since version 6, Redis can move network reading and writing onto extra I/O threads, which is designed to narrow the gap on bigger machines (we did not test that). And most apps never come close to the limit of one Redis thread, which handled about 80,000 requests a second in our test without any batching. If you reach that, pipelining or a second instance is usually cheaper than switching.

What Memcached still does better

• Many cores, one big cache. On a large machine serving huge numbers of small GETs, Memcached uses every core without any tuning.
• Simplicity. There is almost nothing to configure and nothing to persist. For a throwaway cache, that is a feature.
• Predictable memory. The slab allocator avoids fragmentation surprises on long-running caches, at the cost of some wasted space per size class.
• Existing stacks. Older PHP setups and some frameworks have long-standing Memcached support, and WordPress can use it through common object-cache plugins (as it can Redis).

What only Redis can do

These are the reasons most new apps pick Redis even when they only “need a cache” today:

• Sessions that survive a restart. With persistence on, users stay logged in after the cache restarts. Memcached logs everyone out.
• Richer counters and rate limits. Both have atomic increments, but Redis can combine a counter, its expiry and a check atomically in one Lua script or MULTI transaction.
• Job queues and events. Lists, Streams and Pub/Sub power libraries such as Sidekiq, Celery and BullMQ. See our Redis job queue guide and Redis Streams tested.
• Rich structures. Leaderboards with sorted sets, objects with hashes, unique visitors with HyperLogLog.
• A choice of what happens when memory is full. Refuse writes to protect important data, or evict for a cache.

Which one to use

• A new web app, any language: Redis or Valkey. One service covers cache, sessions and queues.
• A pure cache on a large many-core server, already tuned for Memcached: keep Memcached.
• WordPress object cache on shared hosting: use whichever your host provides; both work.
• Sessions or anything you would mind losing on restart: Redis with persistence. Memcached cannot do it.
• You care about an open source licence: Memcached is BSD; so is Valkey, the Redis fork. Our Valkey vs Redis comparison covers that choice.

Distance matters more than either engine. A cache in another country adds its round trip to every read; put it in the same region as the app.

Moving from Memcached to Redis

1. Swap the client, not the logic. get, set with an expiry and delete map directly to Redis GET, SET key value EX seconds and DEL.
2. Do not copy the data. A cache rebuilds itself. Point the app at Redis and let it warm up.
3. Pick an eviction policy. For a pure cache, set allkeys-lru so Redis behaves like Memcached when full (eviction policies explains each one). If you will also store sessions or queues there, keep “refuse writes” instead, or run two separate stores.
4. Watch memory for a day and size the instance for your working set.

On Voroa, a key value store asks this as When memory is full: keep Keep everything for sessions and queues, or choose a drop option for a pure cache. It runs in Mumbai next to the web services you deploy, and the connection URL goes in an environment variable. Details are in the Key Value guide.

Put your cache next to your app

A Redis-compatible store in Mumbai, billed in rupees with a GST invoice, with a free size to start. See the sizes on the managed Redis page.

FAQ

Is Redis faster than Memcached? On our 2-core test, Redis was faster without pipelining and tied with it. Memcached can pull ahead on large many-core servers with many clients, which we did not test.

Does Memcached use less memory than Redis? For plain strings, about the same: 16.7 MB in Redis and 16.8 MB in Memcached for our 100,000 keys. Memcached’s empty process is smaller.

Can Memcached save data to disk? No. A restart empties it. Redis can write snapshots and an append-only log.

Is Memcached still used in 2026? Yes, especially in older PHP stacks and at very large scale. Most new projects choose Redis or Valkey for the extra features.

Can I use Redis just as a cache? Yes. Set a memory limit, an eviction policy such as allkeys-lru, and an expiry on your keys, and it behaves like Memcached.

What is the maximum value size? Redis strings can be up to 512 MB. Memcached items are limited to 1 MB by default.

Tested 7 November 2026 with Redis 8.10.3 and Memcached 1.6.39 in WSL2 on a laptop. Found something out of date? Write to support@getvoroa.com.

On this page

• What each one is for
• We measured the same operations on both
• What the numbers really say
• Where Redis earns its place
• What Postgres can do instead
• A simple decision guide
• Running both without trouble
• FAQ

What each one is for

Neither replaces the other well. Postgres is a poor place for data that should vanish on a timer; Redis is a poor place for anything you cannot afford to lose or need to query in new ways later.

We measured the same operations on both

Setup. On one laptop: Postgres 16.15 running natively on Windows, and Redis 8.10.3 in a Linux virtual machine (WSL2), both loaded with 100,000 keys holding 100-byte values (a Postgres table with a text primary key). The client was Node.js 24 with ioredis and pg, one connection each, sending 5,000 operations one after another with random keys, after a warm-up. We repeated each test three times; the table shows the third run, and the other two were within a few hundredths of a millisecond. Measured 7 November 2026.

One caution on reading this table: Redis sat behind a virtual machine boundary and Postgres did not, so Redis’s round trip was about 0.2 ms slower before it did any work. That is why we include a do-nothing command for each. Compare each operation with its own round trip, not the two databases’ raw numbers.

Memory for the same data: Redis used 17.9 MB of RAM for the 100,000 keys; the Postgres table and its index took 18.8 MB, on disk and cached in memory when used often.

What the numbers really say

Subtract each server’s round trip and you see the work itself:

1. A primary-key read costs Postgres about 0.03 ms. Redis’s GET cost about the same beyond its round trip. For “fetch the row with this ID” at low concurrency, a cache in front of Postgres barely changes how long one request waits. We measured latency with one connection, not capacity: under many concurrent clients Postgres spends far more CPU per lookup than Redis, and that is where a cache in front of it often pays off. We did not measure that here.
2. A durable write costs Postgres about 0.19 ms more than its round trip, because it records the change safely before answering. That cost depends heavily on the disk; ours was a laptop SSD, and cloud volumes are often slower. The same upsert on an UNLOGGED table, which skips that step, cost about 0.05 ms. Redis writes were close to its round trip.
3. The network dwarfs all of it. From a server in Mumbai we measured about 9 ms to a store in the Mumbai region at another provider (on the same private network it is far less) and about 86 ms to Singapore (see our free Redis hosting comparison). A 9 ms round trip is about fifty times the slowest database work we measured, so the region matters far more than which database it is.

So “put Redis in front of Postgres to make reads fast” is clearly right for expensive queries and for high-concurrency read load, and much less important for occasional simple lookups by key.

Where Redis earns its place

These are the jobs where Redis is clearly the better tool, even when Postgres is fast:

• Heavy read load. Many concurrent requests for the same hot data cost Postgres far more CPU than Redis. A cache lets the database spend its capacity on queries only it can answer.
• Expensive results. A query that joins five tables and takes 300 ms is worth caching. Compute once, store the result with an expiry, serve it in a millisecond.
• Data that should disappear on a timer. Sessions, one-time codes, rate-limit windows. Redis deletes expired keys for you; Postgres needs a cleanup job. Our Redis TTL guide covers the traps.
• Very frequent small writes to the same rows. Counters, view counts, “last seen” timestamps. In Postgres every update writes a new row version and must later be cleaned up; a busy counter becomes a hot spot. In Redis it is one INCR.
• Background job queues. Libraries such as BullMQ, Sidekiq and Celery run on Redis. See our Redis job queue guide.
• Fan-out to many servers. Pub/Sub delivers a message to every connected instance, which is how chat and live dashboards stay in sync across servers.
• Protecting the database from spikes. A cache absorbs a burst of identical reads so they never reach Postgres.

What Postgres can do instead

If you would rather run one system for now, Postgres covers more than people expect:

• UNLOGGED tables for cache-like data. Faster writes, as measured above, at the cost of being emptied after a crash. The CREATE TABLE documentation describes the trade-off.
• SELECT ... FOR UPDATE SKIP LOCKED turns a table into a reliable job queue that many workers can pull from without stepping on each other.
• LISTEN / NOTIFY sends simple notifications between connected clients.
• A scheduled cleanup (DELETE ... WHERE expires_at < now()) stands in for key expiry at modest volumes.

Each of these is a reasonable starting point. Each becomes awkward at high volume, which is usually the moment to add Redis.

A simple decision guide

• New app, modest traffic: start with Postgres alone. Add Redis when you have a specific job from the list above, not “for speed”.
• Slow pages: find the slow query first. If it is a lookup by key, add an index. If it is genuinely expensive, cache its result in Redis.
• Sessions: fine in Postgres at low volume; move them to Redis with an expiry when they become a large share of your writes.
• Background jobs: Redis with a queue library, or SKIP LOCKED in Postgres if you want one system.
• Anything you cannot lose: Postgres, always.

Running both without trouble

• Postgres is the source of truth. Anything in Redis should be rebuildable from Postgres, or be something you can afford to lose.
• Set expiries on cached data, so a missed invalidation corrects itself.
• Invalidate on write. When you update a row, delete its cache key in the same code path.
• Keep them together. Put both in the same region as your app; a cache in another region is slower than no cache.

On Voroa, a managed PostgreSQL database and a Redis-compatible key value store run side by side in Mumbai, next to the web services you deploy, each with a free size to start. The store’s details are in the Key Value guide, and its sizes on the managed Redis page.

FAQ

Is Redis faster than Postgres? For the work itself, both handled a single lookup by key in about 0.03 ms in our one-connection test; under heavy concurrent load Redis serves many more lookups per CPU core, which we did not measure. Redis is faster for writes that do not need to be durable and for counters. The network round trip, not the database, set most of the time.

Should I use Redis as my main database? Usually not. It keeps data in memory, can lose the last moments before a crash, and cannot run the queries a relational database can. Use it beside Postgres.

Can Postgres replace Redis? For small apps, often yes: unlogged tables for cache-like data, SKIP LOCKED for queues, LISTEN and NOTIFY for notifications. At high volumes Redis is simpler and faster.

Do I need Redis for sessions? Not at first. Postgres handles sessions fine at modest traffic. Redis helps when session writes become a large share of your database load, and its expiry clears old sessions automatically.

How do I keep Redis and Postgres in sync? Treat Postgres as the truth, write there first, then delete or update the Redis key. Give cached keys an expiry so any missed update corrects itself.

Which is cheaper to run? For the same data, our test used similar memory in both. Redis must hold everything in memory, while Postgres keeps data on disk and caches what is used, so large datasets are usually cheaper in Postgres.

Measured 7 November 2026 with Postgres 16.15 and Redis 8.10.3 on a laptop. Found something out of date? Write to support@getvoroa.com.

This guide walks through a working example, the OnCalendar syntax, and three behaviours we measured on systemd 259 (Ubuntu): how accurate the start time is, what happens when a run is slow, and how Persistent= catches up.

On this page

• How it works: two files
• A complete example
• OnCalendar syntax
• Timezones in OnCalendar
• What we measured
• Commands you will use
• Timers compared with cron
• FAQ

How it works: two files

A timer is always a pair of unit files with the same name:

• backup.service says what to run.
• backup.timer says when to run it.

When the timer elapses, systemd starts the service. Because the service is an ordinary unit, you can also run it by hand with systemctl start backup.service to test it, without waiting for the schedule.

A complete example

A nightly backup at 2 am. Put both files in /etc/systemd/system/:

# backup.service
[Unit]
Description=Nightly database backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

# backup.timer
[Unit]
Description=Run the backup every night at 2 am

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true

[Install]
WantedBy=timers.target

Then load and enable it:

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer
systemctl list-timers backup.timer

Enable the timer, not the service. The service has no [Install] section on purpose: it should only start when the timer fires.

OnCalendar syntax

The format is DayOfWeek Year-Month-Day Hour:Minute:Second, and any part can be *. Check an expression before you use it with systemd-analyze calendar. These were all checked that way:

systemd-analyze calendar --iterations=2 'Mon..Fri 09:30'

It prints the normalised form and the next run times, which catches most mistakes. For a schedule relative to boot or to the last run instead of the clock, use OnBootSec= or OnUnitActiveSec=.

Timezones in OnCalendar

A plain OnCalendar uses the machine’s timezone, which is usually UTC on a cloud server. You can also add a timezone name at the end. We checked both of these with systemd-analyze on a UTC machine:

The second line matters. With standard cron on a UTC server, “2 am IST on the 1st” cannot be written, because it falls on a different date each month in UTC. Our cron timezone guide explains that trap. A timer with a timezone name handles it.

What we measured

We ran three tests with user timers on systemd 259. Each one wrote a timestamp to a file whenever its service started and ended.

1. Start accuracy. systemd’s documentation says the default AccuracySec=1min lets it delay a start by up to a minute, to group wake-ups together. On our idle machine, timers with the default and with AccuracySec=1s both started within one second of the minute. If you need the exact second, set AccuracySec=1s anyway, because a busier machine may not behave like ours.

2. Slow runs do not overlap. A timer every 10 seconds started a job that took 25 seconds. In 60 seconds it started 3 runs, back to back: at 0, 25 and 50 seconds. A new run began the moment the last one ended, and two never ran at once.

Cron behaves differently. It starts a new copy at every match, so the same job would have had up to three copies running together. That is why cron jobs need flock, as our cron troubleshooting checklist explains.

3. Persistent catches up once. We stopped a 10-second timer for 35 seconds, which skipped three runs, then started it again. With Persistent=false, nothing ran until the next scheduled time. With Persistent=true, one run started 0.1 seconds after the restart, not three.

So Persistent=true is the setting for a laptop or a server that reboots: a daily job missed overnight runs once at boot. It also means a daily job can run soon after every boot if the machine is often off at the scheduled time, which surprises some people.

Commands you will use

systemctl list-timers --all              # every timer, last and next run
systemctl status backup.timer            # is it enabled and waiting?
journalctl -u backup.service --since today   # output of the runs
sudo systemctl start backup.service      # run the job now, by hand
sudo systemctl disable --now backup.timer    # stop scheduling it

For a timer that belongs to your own user, put the files in ~/.config/systemd/user/ and add --user to each systemctl command. A user timer only runs while you are logged in, unless lingering is enabled with loginctl enable-linger.

Timers compared with cron

Cron is still quicker for a one-line job. Timers are better when the job matters: you get its output, no overlap and a catch-up after downtime. For the basics of cron itself, see what a cron job is.

The full option list is in the systemd manual pages for systemd.timer and calendar expressions.

Scheduled jobs on Voroa

On a hosting platform you usually do not get systemd at all: your app runs in a container. On Voroa, a Cron Job or Scheduled Task takes a cron expression, read in India Standard Time, and runs your command inside a service that stays running.

It behaves more like cron than a timer. A slow run can overlap the next, and runs missed while the service is stopped are skipped, not caught up. So keep jobs safe to run twice. See scheduling a task on Voroa and worker or cron job. Programs that should run all the time belong on the background workers page.

FAQ

How do I list systemd timers? Run systemctl list-timers --all. It shows each timer with its last and next run.

Do I enable the timer or the service? The timer. Enabling it with systemctl enable --now name.timer makes it start at boot and begin scheduling.

How do I run a timer every 5 minutes? Use OnCalendar=*:0/5, or OnUnitActiveSec=5min for every 5 minutes after the last run.

What does Persistent=true do? If the machine was off when a run was due, the job runs once as soon as the timer starts again, for example at boot. It works only with OnCalendar= timers, and does nothing on a timer’s very first start.

Can a systemd timer run twice at the same time? No. In our test a slow job was started again only after the previous run ended.

Which timezone does OnCalendar use? The machine’s timezone, unless you add a zone name such as Asia/Kolkata at the end of the expression.

Tested on systemd 259 (Ubuntu) on 7 November 2026. Found something out of date? Write to support@getvoroa.com.

On this page

• The plans at a glance
• The break-even point: about 2 commands a second
• Five real workloads, priced
• Why queue workers change the answer
• How to count your own commands
• The free tier, and its limits
• Where Upstash is the right choice
• Alternatives billed by memory
• FAQ

The plans at a glance

As published on Upstash’s Redis pricing page on 7 November 2026. Rupee figures use Rs 93.92 per US dollar (the European Central Bank reference rate for 6 November 2026) and exclude any tax.

Fixed plans add a charge for each extra read region. A Prod Pack (uptime commitment, multi-zone, encryption at rest, SOC-2 and monitoring) adds $200 a month per database.

One counting rule matters a lot: Upstash bills a Lua script as one command plus one for every Redis call the script makes. Libraries that do their work in scripts, such as job queues, use many more billed commands than their network traffic suggests.

The break-even point: about 2 commands a second

The Fixed 250 MB plan costs $10. At $0.20 per 100,000 commands, $10 buys 5 million pay-as-you-go commands. Spread over a 30-day month, that is about 1.9 commands per second, on average, around the clock.

• Below that, pay-as-you-go is cheaper.
• Above it, the fixed plan is cheaper, and the gap grows with every command.

That holds while your data fits in 250 MB. Pay-as-you-go includes the first 1 GB of storage free, so for 250 MB to 1 GB of data the fair comparison is Fixed 1 GB at $20, which breaks even at 10 million commands, about 3.9 a second.

Two commands a second sounds like a lot for a small app, but it is easy to reach without many users, as the next section shows.

Five real workloads, priced

Pay-as-you-go cost for 30 days at $0.20 per 100,000 commands, against the fixed plan that would hold the same data.

The last row is the one that surprises people. A steady 20 requests a second is a modest production app, and on pay-as-you-go its cache costs twenty times the fixed plan. The first row is where pay-as-you-go shines: almost no traffic, almost no bill.

Why queue workers change the answer

The two idle-worker rows come from our own measurements, not estimates. We ran one worker of each library against Redis with an empty queue and counted every command the server executed, including commands run inside the libraries’ Lua scripts, which is how Upstash bills them:

• A BullMQ worker executed about 110 commands a minute while idle. Details in our BullMQ measurements.
• A Celery worker executed about 100 commands a minute while idle. Details in our Celery guide.

An idle worker polls for new work and checks on its peers every few seconds, all day. On a per-command plan you pay for that waiting; each worker costs roughly $9 to $10 a month before it does any work, and real jobs add about 30 commands each on BullMQ. Upstash’s own billing documentation says the same thing and recommends a fixed plan for worker-heavy setups. If your app has a job queue, compare against the fixed plans, or against a host that does not count commands at all.

How to count your own commands

Before choosing, measure. On any Redis you already run:

redis-cli INFO stats | grep total_commands_processed
# wait one hour, run it again, subtract, multiply by 720 for a 30-day month

INFO commandstats breaks the total down by command, which shows quickly whether a worker’s polling or your own reads dominate. In the Upstash console, the database page shows daily command counts once you have traffic.

The free tier, and its limits

The free database gives 250 MB, 500,000 commands and 10 GB of bandwidth a month, one database per account, with no card. Two catches matter in practice: one idle queue worker uses the 500,000 commands in about three days, and a free database is archived after at least 30 days without activity (you can restore it). For a side-by-side of every free Redis tier, see our free Redis hosting comparison.

Where Upstash is the right choice

• Serverless and edge functions. Upstash answers over HTTP as well as the Redis protocol, so a function does not need to hold a connection open. That is its real strength, and few hosts match it.
• Spiky or very low traffic. Pay-as-you-go costs almost nothing when nothing happens.
• Global reads. Read regions put copies of your data near users in several countries.

It is a weaker fit for long-running servers with steady traffic and for anything with background workers, where a flat price is simpler and usually cheaper. Upstash offers that too, through its fixed plans; the mistake is staying on pay-as-you-go out of habit.

Alternatives billed by memory

If your app runs in India on long-running servers, a store billed by memory removes the command-count question entirely. For comparison, Voroa’s key value sizes are priced in rupees, billed with a GST invoice, and never count commands:

The memory figure is the whole instance, and up to 40% can be held back for the nightly save, so a 256 MB store may hold about 150 MB of data. It runs in Mumbai beside the web services and background workers you deploy, with no eviction by default, which is what a job queue needs. The other sizes are on the managed Redis page, and setup is in the Key Value guide.

FAQ

How much does Upstash Redis cost per month? Pay-as-you-go is $0.20 per 100,000 commands plus storage beyond 1 GB. Fixed plans start at $10 a month for 250 MB with no monthly command count. The free plan includes 500,000 commands.

Is Upstash pay-as-you-go or fixed cheaper? Below about 5 million commands a month (roughly 2 a second on average), pay-as-you-go. Above that, the fixed plan.

Why is my Upstash bill high? Usually background polling: job queue workers, cron libraries and health checks send commands all day. Scripts are billed per Redis call inside them, too.

Does Upstash charge for idle connections? It charges for commands, not connections. An idle queue worker still sends commands while it waits, and those are billed.

Is there an Upstash region in India? Upstash lists Mumbai (ap-south-1) among its AWS regions. Choose it if your app runs in India.

Can I pay Upstash in rupees with a GST invoice? Upstash prices in US dollars. If you need rupee billing with a GST invoice, look for an Indian provider.

Prices from Upstash’s Redis pricing page and billing documentation on 7 November 2026. Converted at Rs 93.92 per US dollar. Prices change; check the Upstash page before you commit. Found something out of date? Write to support@getvoroa.com.

On this page

• The short answer
• How one database became two
• Side by side: what differs in November 2026
• We benchmarked both on the same machine
• Where the two are no longer interchangeable
• Which licence affects you
• Cost: where the engine changes the bill
• Which one to pick
• Switching from Redis to Valkey
• FAQ

The short answer

For caching, sessions, rate limits and queues, Redis and Valkey behave the same and perform the same on small machines. Pick Valkey if you want a permissive BSD licence and lower managed prices. Pick Redis 8 if you need its built-in JSON, search and vector features, or Redis Ltd’s own cloud and support. If a host runs one for you, the engine rarely changes your code.

How one database became two

Redis was BSD-licensed open source for 15 years. Then the licence changed, a fork followed, and both projects have shipped steadily since.

So both are open source again, in different ways. Redis offers a copyleft licence (AGPLv3) next to its source-available ones. Valkey stays permissive (BSD-3-Clause).

Side by side: what differs in November 2026

The everyday commands you use for a cache or a queue (GET, SET, EXPIRE, INCR, lists, hashes, sorted sets, streams, pub/sub, Lua scripts) are the same in both. What a managed store adds on top of the engine (backups, TLS, password rotation) is covered in managed databases on Voroa.

We benchmarked both on the same machine

Most comparison pages repeat headline numbers like “1 million requests per second” or “37% faster” without saying where they came from. Valkey’s own 1.19 million figure was measured with 8 I/O threads on a 64-core AWS machine. Most apps run on something much smaller, so we tested that.

Setup. We built Redis 8.10.3 and Valkey 9.1.3 from source and ran both inside the same Linux virtual machine (WSL2) on a 4-vCPU laptop. That is a modest, noisy machine, which is part of the point: it is closer to a small cloud instance than a 64-core benchmark rig. We gave the server 2 CPU cores and the benchmark client 2 other cores, and turned persistence off on both. The same client (redis-benchmark) sent 1,000,000 commands per run with 50 connections, 256-byte values and 100,000 random keys. We ran every test 5 times and report the median. Measured 7 November 2026.

What we found.

1. On a small server it is a tie. The differences are 13% at most, and they flip direction from test to test. The ranges above overlap in every test: Redis’s own five SET runs with pipelining spread from 641k to 884k, far wider than the gap between the two engines.
2. Pipelining beats the engine choice by a mile. Sending 16 commands per round trip gave 6 to 8 times the throughput on both. If your app is slow on Redis, batch your commands before you change engines.
3. I/O threads need spare cores. With 2 I/O threads on the same 2 cores, both engines got slower without pipelining. GET fell from 110,951 to 91,819 per second on Redis and from 114,090 to 90,818 on Valkey, and the five-run ranges did not overlap (88k-94k against 106k-116k). Valkey’s threading gains appear when the server has cores to spare, which a small instance does not.
4. Memory use is the same. In a separate run that wrote 200,000 random keys with 256-byte values (about 126,000 distinct keys after repeats), Redis used 48.1 MB and Valkey 48.7 MB.

This is a small-machine test on purpose. On a large instance with many cores and many clients, the threading work in Valkey 8 and later can open a real gap; if that is your scale, test on your own hardware.

Where the two are no longer interchangeable

For most apps the switch is invisible. These are the places it is not:

• Data files from Redis 7.4 and later. Valkey reads RDB and AOF files from Redis up to 7.2. A snapshot written by Redis 7.4 or 8 cannot be loaded into Valkey directly. Move the data by replication or by copying keys instead.
• Redis 8’s built-in types. Vector sets (VADD, VSIM and friends) exist only in Redis. JSON, Bloom filters and search exist in Valkey as modules, so check that your host loads them before you rely on them.
• Redis Ltd’s own products. Redis Cloud features such as Redis Flex and Active-Active are Redis only.
• Client libraries. Every major Redis client works with Valkey. Valkey also publishes its own client, GLIDE, but you do not need it.

Which licence affects you

If you use the database inside your own app: neither licence costs you anything or asks anything of you. Running Redis 8 or Valkey behind your SaaS, your API or your mobile app is free under every option.

If you change the database’s own source code: under AGPLv3, if users interact with your modified version over a network, you must offer them your changes. Valkey’s BSD licence has no such condition. Very few teams modify the database itself.

If you sell the database as a hosted service: this is what RSALv2 and SSPLv1 were written to restrict. It is why AWS, Google and many smaller hosts moved to Valkey. The details are on the official Redis licence page.

Cost: where the engine changes the bill

The engine affects price mainly on the big clouds. On AWS ElastiCache, Valkey is priced 20% lower than Redis OSS on node-based clusters and 33% lower on serverless, and the serverless minimum is 100 MB for Valkey against 1 GB for Redis OSS (ElastiCache pricing). For a small cache that minimum is often the biggest number on the bill.

On smaller hosts you usually pay for memory and do not choose the engine at all. Our free Redis hosting comparison lists what each free tier limits and where it runs.

Which one to pick

• A cache, sessions, rate limits or a job queue: either. Pick the one your host offers in the region closest to your users; distance matters far more than the engine.
• You want a permissive licence and a vendor-neutral project: Valkey.
• You want vector search or JSON without loading modules: Redis 8.
• You are on AWS or Google Cloud: Valkey, for the lower price and because that is where the managed service is going.
• You want Redis Ltd’s support or Redis Cloud features: Redis.
• You use BullMQ, Sidekiq or Celery: either should work, since they rely on core commands and Lua scripts, which both support; run your test suite before you switch. Run the consumer as a background worker in the same region as the store.

Switching from Redis to Valkey

1. Check the source version. From Redis 7.2 or earlier, a snapshot loads straight into Valkey. From 7.4 or 8, plan to replicate or copy keys.
2. Check for Redis-only commands. Search your code for vector set commands and module commands (JSON., FT., BF.) and confirm the target has them.
3. Change the URL, not the client. Point your existing client at the new address. Run your test suite.
4. Watch memory and eviction for a day. Make sure the new instance has the same maxmemory and eviction policy as the old one.

On Voroa, a key value store is Redis-compatible: your existing client connects with the URL you copy from the database page, and nothing else in your code changes. Moving existing data in is covered in importing an existing database, and connection details are in the Key Value guide.

Run a Redis-compatible store next to your app

Whichever engine you prefer, what decides speed for an app in India is distance. Voroa runs a Redis-compatible key value store in Mumbai beside the services you deploy, billed in rupees with a GST invoice, with a free size to start. See the sizes on the managed Redis page.

FAQ

Is Valkey a drop-in replacement for Redis? For Redis up to 7.2 and for everyday commands, yes. Clients, commands and the protocol are the same. Data files from Redis 7.4 and later, and Redis 8’s built-in vector sets, are the exceptions.

Is Valkey faster than Redis? On our 2-core test, no: the two were within 13% of each other and the winner changed from test to test. Valkey’s published gains come from I/O threads on large many-core machines.

Is Redis still open source? Redis 8 and later can be used under AGPLv3, which is an open source licence. Redis 7.4 was source-available only. Redis 7.2 and earlier are BSD.

Why did AWS and Google move to Valkey? Redis’s 2024 licences restrict offering Redis as a managed service. Valkey’s BSD licence does not, so AWS, Google and many smaller hosts now run Valkey. Azure’s managed offering is Redis.

Will my BullMQ, Sidekiq or Celery setup work on Valkey? They should. They rely on core commands and Lua scripts, which Valkey supports. We have not tested each library on Valkey, so run your own test suite before you switch.

Should I use Valkey or Redis for a new project in India? Choose by host and region first. A store in Mumbai next to your app will be faster than either engine in Singapore. Distance matters more than the engine.

Last updated: 7 November 2026. We re-check versions and re-run the benchmark when a major release ships. Found something out of date? Write to support@getvoroa.com.

It is simple, and it has rules that surprise people: a once-a-day limit on the free plan, UTC-only times, no retries, and occasional duplicate runs. This guide covers the setup and each rule, all from Vercel’s own documentation, checked on 7 November 2026.

On this page

• How they work
• Setup in two files
• Plan limits
• Seven rules that catch people out
• Securing the endpoint with CRON_SECRET
• Schedules: the replacement
• When to run cron somewhere else
• FAQ

How they work

At each scheduled time, Vercel makes an HTTP GET request to your production deployment, at the path you configured. The request carries the user agent vercel-cron/1.0 and an x-vercel-cron-schedule header with the expression that triggered it.

Your function runs as a normal request. So the job is limited by your function’s maximum duration, and it only exists while that request is being handled.

Setup in two files

// vercel.json
{
  "crons": [
    { "path": "/api/digest", "schedule": "30 3 * * *" }
  ]
}

// app/api/digest/route.js  (Next.js App Router)
export async function GET(request) {
  if (request.headers.get('authorization') !== `Bearer ${process.env.CRON_SECRET}`) {
    return new Response('Unauthorized', { status: 401 });
  }
  await sendDailyDigest();           // your code
  return Response.json({ ok: true });
}

30 3 * * * is 3:30 UTC, which is 9:00 am in India. Vercel schedules in UTC only.

Plan limits

On Hobby, an expression that runs more than once a day, such as 0 * * * *, fails the deployment. And a job set for 0 8 * * * can start any time from 08:00 to 08:59 UTC. Source: Vercel cron usage and pricing.

Seven rules that catch people out

1. Failed runs are not retried. If the function errors, Vercel does not try again. You find out only from the logs.

2. Delivery is best effort. Vercel says a network error can occasionally stop a run from reaching your function, and then nothing runs and nothing is logged.

3. A run can arrive twice. Vercel also says the same scheduled run can occasionally be delivered more than once. Make the job safe to repeat.

4. Runs can overlap. If a run takes longer than the interval, Vercel can start the next one anyway. Vercel suggests a lock, for example in Redis, to allow only one at a time.

5. Only production runs crons. Preview deployments never trigger them. Test by calling the path yourself.

6. Redirects end the run. Cron requests do not follow redirects. With Next.js trailingSlash turned on, /api/digest redirects to /api/digest/ and your function never runs. Put the trailing slash in the configured path.

7. Expression limits. No names such as MON or JAN, and you cannot set both day-of-month and day-of-week; one of them must be *.

These come from Vercel’s managing cron jobs page. Rules 3 and 4 are the same lessons we measured for in-process schedulers: our node-cron tests saw both duplicate and overlapping runs.

Securing the endpoint with CRON_SECRET

A cron path is a public URL, so anyone could call it. Vercel’s fix:

1. Add an environment variable CRON_SECRET, a random string of at least 16 characters.
2. Vercel sends it in the Authorization header as Bearer <secret> on every cron call.
3. Your function rejects any request without the matching header, as in the code above.

Each deployment keeps the secret it was built with. Changing CRON_SECRET does nothing until you redeploy, and an instant rollback brings back the older deployment’s secret.

Schedules: the replacement

Vercel now describes Cron Jobs as a legacy feature that will move to Schedules, which add timezones and private function targets. Schedules were in public beta at the time of writing.

The limits change too. According to Vercel’s migration guide, Hobby schedules can run as often as once every 15 minutes, within a 15-minute window, instead of once a day.

If timezones are the reason you are reading this, check the Schedules documentation before building around UTC. Existing cron routes can move to Schedules without code changes, according to Vercel.

When to run cron somewhere else

Vercel cron is a good fit for short tasks that are safe to retry by hand: refreshing a cache, sending a digest, syncing a small list. Consider a separate cron service when:

• The job runs longer than your function’s maximum duration.
• You are on Hobby with legacy Cron Jobs and need more than one run a day.
• Your users are in India and you want schedules in IST without converting from UTC (legacy Cron Jobs are UTC-only).

For the general limits of each platform side by side, see our guide to cron every 5 minutes.

Running scheduled jobs on Voroa

On Voroa, a Cron Job runs a command from your repository on a schedule, as a process rather than an HTTP request to a function. Schedules are in India Standard Time and can run as often as every minute.

Voroa builds the repository into a small service that stays running, so a slow run can overlap the next. Runs are skipped while the service is stopped, for example after a free workspace uses its monthly free hours. Voroa does not retry a failed run either, so keep jobs idempotent and record each success.

Setup is in scheduling a task on Voroa, and you can host the Next.js app itself as a web service. Long-running consumers belong on the background workers page.

FAQ

Are Vercel cron jobs free? They are included on every plan; you pay for the function time they use. On Hobby they can run at most once a day.

What timezone do Vercel cron jobs use? UTC, always. For 9 am in India, write 30 3 * * *.

Why is my Vercel cron job not running? Common causes: it is a preview deployment, a redirect such as trailingSlash, a 401 from a CRON_SECRET mismatch, or a Hobby expression that runs more than once a day.

Does Vercel retry failed cron jobs? No. A failed invocation is not retried. Check the logs from the Cron Jobs settings page.

Can a Vercel cron job run twice? Yes, occasionally. Vercel says delivery can repeat a run, and a long run can overlap the next.

How do I secure a Vercel cron job? Set CRON_SECRET, then reject requests whose Authorization header is not Bearer plus that secret.

Checked 7 November 2026 against Vercel’s documentation. Found something out of date? Write to support@getvoroa.com.

This guide explains how cron works, how to read and write a schedule, and the few mistakes that cause most cron problems. It ends with where to run cron jobs when you do not manage your own server.

On this page

• How cron works
• The five fields
• Examples you can copy
• Working with crontab
• Five mistakes that break cron jobs
• Cron job or background worker?
• Where to run cron jobs today
• FAQ

How cron works

On a Linux server, a small program called the cron daemon wakes up every minute. It reads a list of jobs, checks which ones are due at that minute, and runs them.

Each job is one line: a schedule followed by a command. The list is called a crontab (“cron table”). Each user on the server has their own.

# minute hour day-of-month month day-of-week  command
0 2 * * * /home/app/backup.sh

That line runs backup.sh at 2:00 am every day.

The five fields

Read it left to right. 30 9 * * 1-5 means minute 30, hour 9, any day of the month, any month, Monday to Friday: 9:30 am on weekdays.

One quirk: if you set both day-of-month and day-of-week, standard cron runs when either matches. 0 9 1 * 1 runs on the 1st of every month and every Monday.

Examples you can copy

Some step values do not divide an hour evenly and leave short gaps. Our guide to cron every 5 minutes shows which ones and why.

Working with crontab

On a Linux server:

crontab -e      # edit your crontab (opens an editor)
crontab -l      # list your jobs
crontab -r      # remove ALL your jobs - careful

A safe line looks like this:

*/15 * * * * cd /home/app && /usr/bin/node scripts/sync.js >> /var/log/sync.log 2>&1

It uses full paths, changes to the right folder, and sends both output and errors to a log file so you can see what happened.

Five mistakes that break cron jobs

1. The wrong timezone. Cron uses the server’s timezone, which is usually UTC on cloud servers. 0 9 * * * then runs at 2:30 pm in India. To run at 9 am IST on a UTC server, write 30 3 * * *.

2. A missing PATH. Cron runs with a very short PATH, so node or python may not be found. Use full paths such as /usr/bin/node.

3. No output anywhere. By default cron’s output is mailed or lost. Redirect it to a log file, as above, or nothing tells you the job failed.

4. Overlapping runs. Cron starts each run on time even if the last one is still going. On Linux, flock -n skips a run while the previous one holds a lock.

5. Duplicate runs. If the same crontab, or the same in-app scheduler, runs on two servers, every job runs twice. We measured exactly that with node-cron in Node.js: two instances, 40 runs instead of 20.

Cron job or background worker?

Both run code with no web page. The difference is whether the program is meant to stop.

If your script ends on its own, it is a cron job. If it should still be running tomorrow, it is a worker.

Where to run cron jobs today

Hosting platforms differ a lot here. GitHub Actions runs schedules at most every 5 minutes, Heroku Scheduler every 10 minutes, and most use UTC. The GitHub Actions schedule docs are a typical example.

Cron jobs on Voroa

On Voroa you can create a Cron Job from a GitHub repository: give it a command and a schedule, from a preset such as Every hour or a cron expression. Schedules run in India Standard Time, so 0 9 * * * means 9:00 am IST.

Voroa builds the repository into a small service that stays running and runs your command inside it. A slow run can overlap the next, so keep jobs safe to run twice. Runs are also skipped while the service is stopped, for example after a free workspace uses its monthly free hours, so do not rely on every run firing.

Details are in scheduling a task on Voroa, and worker or cron job helps you pick. Long-running processes go on the background workers page.

FAQ

What is a cron job in simple words? A command that runs automatically on a schedule, such as every night or every 15 minutes.

What does * * * * * mean? Every minute of every hour of every day. Each star means “any value” for that field.

What is the difference between cron and crontab? Cron is the program that runs scheduled jobs. A crontab is the file listing those jobs.

What timezone does a cron job use? The server’s timezone, usually UTC in the cloud. Check it before you pick an hour.

Can a cron job run every second? Not with standard cron, whose smallest unit is one minute. Some in-app schedulers accept a seconds field.

How do I see if my cron job ran? Send its output to a log file, or have the job record its result somewhere you can check, such as a row in a database.

Updated 7 November 2026. Found something out of date? Write to support@getvoroa.com.

This page compares free PostgreSQL hosting the way you would actually use it: as free database hosting for an app that has to keep working. We run a Postgres fleet in Mumbai, so we did not only read pricing pages. We measured. Every latency number below was taken by us on 16 October 2026, from a home broadband connection in India and from a server in Mumbai. Every limit was re-checked against the provider’s own pricing page or documentation on 14 November 2026.

On this page

• Which Postgres providers have generous free tiers?
• Best free Postgres database for each use case
• Free PostgreSQL hosting compared: 14 options
• Each free tier in a few lines
• Free Postgres latency from India, measured
• The four ways a free Postgres stops working
• Neon free tier: the day-17 problem
• When to leave a free tier, and what the paid floor costs
• How to create a free Postgres database online, step by step
• FAQ

Which Postgres providers have generous free tiers?

Yes, several do. Judged on three things - how much storage you get, whether the database expires, and whether it stops when idle - the most generous free Postgres tiers in November 2026 are CockroachDB Basic, Layerbase, Netlify Database, Prisma Postgres and Neon. None of them expires, but each one sleeps, meters usage or caps something else.

1. CockroachDB Basic: 10 GiB and 50 million request units a month. Postgres-compatible rather than Postgres, and the allowance is for accounts paying by card.
2. Layerbase: 5 GB across up to 2 databases, no card. Databases sleep and wake on connect.
3. Netlify Database: 5 GB per database, up to 3. Its compute is paid from the same 300 monthly credits as your Netlify site.
4. Prisma Postgres: 2 GB shared by up to 50 databases, with 200,000 queries a month.
5. Neon: 1 GB per project across up to 100 projects (20 GB in total), with 100 compute hours per project.

If your users are in India, add a fourth test: a region near them. Of these five, only CockroachDB Basic offers Mumbai.

Best free Postgres database for each use case

• Learning SQL, or a project you open a few times a week: Neon. 1 GB per project, a real Postgres, and scale-to-zero means you only spend compute while you are working.
• An app with logins, file uploads and a database in one place: Supabase, in its Mumbai region. Keep it busy every week or it is paused.
• A database that has to stay awake 24 hours a day for free: one that does not meter compute hours, such as Nile or Aiven. Neon’s allowance runs out around day 17 if the database never sleeps (the maths is below).
• Many small databases, one per experiment: Prisma Postgres, up to 50 databases sharing 2 GB.
• A hackathon or a demo next week: anything on this list. Write down the expiry date if you pick Render.
• Your users are in India: pick a Mumbai region. From our tests, Singapore adds about 40 ms to every query from a home connection and about 55 ms from a Mumbai server, compared with Mumbai.

Free PostgreSQL hosting compared: 14 options

Every free Postgres hosting option we could verify, with limits as published by each provider on 14 November 2026. Sources: Neon plans, Supabase pricing and compute docs, Aiven free tier docs, Render free tier and pricing, Railway plans, Koyeb databases docs, Prisma Postgres free plan, Nile pricing, CockroachDB Basic, Netlify Database limits, Layerbase, the AWS free tier page, Microsoft’s Azure free account guide and Voroa free instances.

Three notes on the table. CockroachDB speaks the Postgres wire protocol but is a different database underneath, so some Postgres features and extensions will not work. AWS and Azure free periods end. Netlify Database’s compute and bandwidth are taken from the same credits as the rest of a Netlify team; our guide to Netlify free plan limits explains how that pool runs out.

Each free tier in a few lines

Neon

A real Postgres with 1 GB per project and up to 100 projects, capped at 20 GB in total. Compute scales to zero after 5 minutes and cannot be kept on. When a project uses its 100 CU-hours, compute is suspended until next month, but Neon says none of its limits delete your data.

Supabase

500 MB of database, shared CPU and 0.5 GB RAM, with two active projects. A project is paused after a week of inactivity, and there are no automatic backups on Free. It is the only big free tier here with a Mumbai region.

Aiven

1 GB on a 1 CPU, 1 GB RAM machine, with no time limit and no card. The catch is 20 connections with no pooling, and Aiven chooses the cloud and region for you. One free service of each type per organisation.

Render

1 GB and 256 MB RAM, one free database per workspace. It is deleted 30 days after creation unless you upgrade within a 14-day grace period, and it has no backups.

Railway

There is no free database as such: a one-time $5 trial credit, then $1 of credit a month on the Free plan, with a 0.5 GB volume. When the credit runs out, workloads stop, and volume data is deleted 30 days after the plan expires.

Koyeb

One free database instance with 1 GB, a quarter of a vCPU and 1 GB RAM, but only 5 hours of compute a month. It sleeps after 5 minutes idle, which is what makes those 5 hours last.

Prisma Postgres

The free plan grew this year: 2 GB per workspace shared by up to 50 databases, and 200,000 queries a month, with no card. Idle databases scale to zero, and once the monthly queries are used, queries stop until the 1st. There are no backups on Free.

Nile

1 GB, 50 million query tokens and up to 500 connections, and the database never pauses. There are no backups on Free, and the regions are in the US and Europe only.

CockroachDB Basic

The biggest free storage allowance here: 10 GiB and 50 million request units a month, worth $15 of usage. It scales to zero when idle and offers Mumbai. The allowance applies to organisations paying monthly by card or marketplace, and it is CockroachDB, not Postgres.

Netlify Database

Managed Postgres, generally available since 28 April 2026. Free gives up to 3 databases with 5 GB each, sleeping after 5 minutes, with backups kept 3 days. Compute and bandwidth come out of the 300 credits a Netlify team gets each month, so a busy database can pause the site too.

Layerbase

5 GB across up to 2 databases, no card and no expiry. Small databases sleep and wake when you connect, in about one to five seconds by Layerbase’s own figures. Its page does not state connection limits or a region for free databases.

Voroa

One free Postgres per account in Mumbai: 1 GB, 0.1 CPU, 256 MB RAM and 20 connections. It is not paused for inactivity, but it shares the workspace’s 750 free hours a month, and there are no backups on the free size. More detail is in the Voroa section below.

Free Postgres latency from India, measured

We timed TCP connections to each provider’s public database endpoint, 20 attempts each, and report the median. A TCP connect is one network round trip, which is the floor for every query you send. For Neon we also created a free project in Singapore and timed real queries end to end with psycopg, including new connections and a cold start after the database had scaled to zero.

From a home broadband connection in India

From a server in Mumbai (where your app runs, if you host it in India)

Real queries against a free Neon database in Singapore, from India

What those numbers mean for your app

A cold start costs 0.7 to 1.1 seconds on top. After 7 minutes idle the free Neon database had scaled to zero.

Across three runs the first connection then took 1.24 to 1.64 seconds against 0.56 seconds warm, so the wake-up itself was roughly 0.7 to 1.1 seconds. The connection straight after it was back to normal. That is fast for a database waking from zero, and it is still the first thing a visitor waits for after a quiet spell.

Latency multiplies by the number of queries. A typical API request does not send one query. It checks the session, loads the user, loads the thing the page is about, and writes a log row. Call it five queries, sent one after another.

From a server in Mumbai that is about 15 ms of waiting with the database in Mumbai, and about 300 ms with the database in Singapore. Your code has not done anything yet, and the user already feels it.

New connections are the expensive part. Opening a connection to Postgres over TLS takes several round trips before the first query runs: TCP, TLS, then password authentication. Against Singapore from India we measured about 560 ms for that.

A long-running server opens its connections once and reuses them, so it pays this rarely. A serverless function that opens a fresh connection on every request pays it every time. If you deploy on serverless, use the provider’s pooled connection string or a pooling driver.

Put the app and the database in the same region. A database in Mumbai with an app in Oregon is worse than both in Singapore. Check where your app runs before you choose where the database lives.

The four ways a free Postgres stops working

Free tiers end in one of four ways. Knowing which one applies tells you more than the storage figure.

1. It sleeps. Neon, Koyeb, Prisma Postgres, Netlify Database, Layerbase and CockroachDB scale compute to zero when idle and wake on the next query. Nothing is lost; the first request after a quiet period is slower.

2. It is paused or stopped. Supabase pauses a free project after a week without enough activity. A paused project does not answer at all until you restore it from the dashboard. Supabase emails a warning about a week before. A paused project can be restored for up to a year (Supabase project pausing). Our Supabase free tier limits guide covers each limit in detail, and the Supabase backup guide shows how to keep your own copy. On Voroa, a free database is stopped, with its data kept, when the workspace’s free hours run out, and starts again on the 1st.

3. It is deleted. Render deletes a free database 30 days after creation, plus a 14-day grace period (Render free tier docs; more in our Render alternative comparison). Prisma deletes an instant database you never claimed after 24 hours. AWS closes the free-plan account after 6 months or when the credit runs out, and says you are not charged unless you move to a paid plan. Azure’s free amounts end after 12 months, and then normal billing applies.

4. It hits a wall. Every free tier has a hard limit that changes behaviour without warning your users:

• Supabase puts the database into read-only mode above 500 MB. Inserts start failing with cannot execute INSERT in a read-only transaction.
• Neon blocks writes that would grow storage past 1 GB, and when a project uses up its 100 CU-hours, its compute is suspended until the next month: existing connections drop and new ones cannot open (Neon free plan limits). How Neon and Supabase differ beyond the free tier is in Neon vs Supabase.
• Prisma Postgres stops answering queries once the month’s 200,000 are used, until the 1st or until you upgrade.
• Aiven allows 20 connections and no pooling. A serverless app can use that up in one busy minute and start failing with too many connections.

Neon free tier: the day-17 problem

Neon’s free compute is generous for a database that sleeps, and tight for one that never does. The free compute starts at 0.25 CU, so 100 CU-hours buys 400 hours of running time. A month has about 730 hours. If something touches the database at least every five minutes, around the clock, it never scales to zero and the allowance runs out after roughly 16.7 days. From then until the 1st of next month, the project’s compute is suspended.

What keeps a database awake is often not your users. An uptime monitor that pings an endpoint every minute, a cron job, or a worker that polls a queue is enough. If you need a database that is awake 24 hours a day, either remove those callers or pick a tier that does not meter compute hours.

When to leave a free tier, and what the paid floor costs

Move to a paid size when any of these becomes true:

• You need backups. Supabase, Render, Prisma Postgres, Nile and Voroa have none on their free sizes.
• Real users depend on it. A pause, a monthly cap or a deletion date is fine for a demo, not for customers.
• You are close to a cap. Storage, compute hours or monthly queries: hitting one stops writes or the whole database, usually at a busy moment.
• You need it awake all day. A tier that sleeps or meters compute hours adds cold starts and a month-end cliff.

The cheapest paid step on each provider, from their own pricing pages on 14 November 2026:

Dollar prices are before tax and your card’s foreign currency markup. Voroa’s sizes are billed in rupees with a GST invoice; the full list is on the pricing page.

Free Postgres tiers that disappeared

The list of free Postgres options keeps changing, which is a reason to keep your own copy of your data whatever you choose:

• Heroku removed free Postgres on 28 November 2022 and deleted databases that were not upgraded.
• ElephantSQL stopped taking sign-ups in May 2024 and shut down on 27 January 2025.
• Vercel Postgres moved every database to Neon in December 2024.
• Tembo stopped creating new cloud instances on 5 May 2025.
• Xata no longer has a managed free tier; its pricing page offers a free trial, and the open-source version is free to run yourself.
• Fly.io no longer gives free Postgres to new accounts.
• Neon raised free storage from 0.5 GB to 1 GB per project on 2 October 2026, and Prisma Postgres now gives 2 GB per workspace. Many comparison pages still show the old figures.

The habit that protects you on any provider takes one line:

pg_dump "$DATABASE_URL" --format=custom --file=backup-$(date +%F).dump

Run it weekly. If your provider changes its free tier, you restore that file somewhere else with pg_restore and move on. On Voroa the same file goes in through Import an existing database.

Is PostgreSQL free?

Yes. PostgreSQL itself is free and open source under the PostgreSQL License, a short permissive licence similar to MIT and BSD. You can use it, change it and ship it inside a commercial product without paying anyone and without publishing your own code.

Is PostgreSQL free for commercial use? Yes, with no user limit, no core limit and no paid “enterprise edition” of the database itself. Companies that sell Postgres sell the work around it: running the server, backups, upgrades and support.

That is why this page exists. The database costs nothing; the machine it runs on does. A free Postgres database is a provider choosing to pay for a small machine on your behalf, and the catch in each free tier is how they keep that cost bounded.

Free managed Postgres in Mumbai on Voroa

Voroa’s free plan includes one managed Postgres per account: 1 GB of storage, 256 MB of RAM, 0.1 CPU and up to 20 connections, in Mumbai, with no card. It is not paused for inactivity and not deleted after a fixed time.

It does share the workspace’s 750 free running hours a month with your free web services, workers and cron jobs. One free database on its own runs all month within that. A free database and a free web service running all month use the hours in about 16 days; then both are stopped, with nothing deleted, until 12 midnight IST on the 1st. If a paid app depends on the database, move the database to a paid size too.

The other trade-offs are real: it is a small machine, like Render’s free database; there are no automatic backups on the free size, so keep your own pg_dump; and free database capacity is shared, so if the platform is full, a new free database is refused with a clear message rather than queued.

Paid sizes are billed in rupees, by UPI or card, with a GST invoice. Details are in Free instances on Voroa.

How to create a free Postgres database online, step by step

You can get a free Postgres database online in about two minutes, from the browser, with no card and nothing to install. You need a Voroa account; sign-up is with email or GitHub.

Step 1. Choose Postgres. In the dashboard, select New, then Postgres from the list of services.

Step 2. Name the database. PostgreSQL is already selected as the database type. Type a name using lowercase letters, numbers and hyphens, for example shop-db. Leave the Postgres database name empty and Voroa generates one. The region is Mumbai.

Step 3. Pick the free size. Under Instance type, choose DB Nano. It shows Free, and the monthly total at the bottom of the page reads Free as well, with 1 GB of storage included.

Select Create database. If the platform’s shared free capacity is full at that moment, you see a clear message instead of a half-created database.

Step 4. Copy the connection URL. Your database opens on the Connect tab. With An app on Voroa selected, the URL there is your DATABASE_URL. Select the eye icon to show the password, then copy the whole line into your app’s environment variables. This address works only from apps running on Voroa in the same workspace, which keeps the traffic inside Mumbai.

Step 5. Connect from your laptop, if you need to. Switch to Outside Voroa to get a second address for psql, pgAdmin, DBeaver or an app hosted elsewhere. Connections are encrypted with TLS. If the tab shows OFF, choose Enable external access; the database restarts for a few seconds. Choose Only addresses I trust if you know the IP addresses that will connect. Full details are in connecting to Postgres from outside Voroa.

Step 6. Use it from your code. Under Connect from your code pick psql, Node.js, Prisma, Python or Go and copy a ready snippet that reads DATABASE_URL from the environment.

That is the whole setup. What each connection detail means is explained in PostgreSQL connection details.

FAQ

Are there Postgres database providers with generous free tiers? Yes. By storage, CockroachDB Basic (10 GiB), Layerbase (5 GB), Netlify Database (5 GB per database) and Prisma Postgres (2 GB per workspace) give the most, and Neon gives 1 GB per project across up to 100 projects. Each has a catch: sleeping, a usage cap, or a card requirement.

Is there a completely free Postgres database? Yes. Neon, Supabase, Aiven, Koyeb, Prisma Postgres, Nile, Netlify Database, Layerbase and Voroa all offer a free Postgres with no end date. Each has a catch: sleeping, pausing, a usage allowance, or a small machine.

Which free Postgres tier does not expire? Neon, Supabase, Aiven, Koyeb, Prisma Postgres, Nile, CockroachDB Basic, Netlify Database, Layerbase and Voroa have no expiry date. Render’s free database is deleted 30 days after creation plus a 14-day grace period. The AWS free plan closes after 6 months and Azure’s free amounts end after 12.

Which free Postgres does not sleep or pause? Render, Aiven (unless it is unused) and Nile keep running. Voroa is not paused for inactivity, but it stops if the workspace’s free hours run out. Neon, Koyeb, Prisma Postgres, Netlify Database and Layerbase scale to zero when idle. Supabase pauses a project after a week of low activity.

Can I get free Postgres hosted in India? Supabase, CockroachDB Basic and Voroa offer a Mumbai region on their free tiers. AWS Mumbai and Azure Central India are free only on their time-limited offers. Neon, Render, Railway, Koyeb and Prisma Postgres are closest in Singapore.

Is PostgreSQL free for commercial use? Yes. The PostgreSQL License lets you use it in commercial software for free. Hosting it is what costs money, which is what the free tiers above cover.

Where can I get free Postgres for testing? For automated tests, run Postgres in a Docker or CI container so every run starts clean. For a shared staging database, any free hosted tier on this page works; keep destructive tests off it.

Do I need a credit card for free Postgres hosting? Not for Supabase, Aiven, Prisma Postgres, Layerbase or Voroa. CockroachDB’s free allowance is for organisations paying by card or marketplace, and AWS and Azure free offers are tied to a billing account.

Is a free Postgres tier good enough for production? For a small app with modest traffic, sometimes, if you accept the catch of the tier you pick and keep your own backups. None of the free tiers in this list comes with an uptime commitment.

How much latency does a Singapore database add for users in India? In our tests, about 40 ms per query from a home connection and about 55 ms per query from a server in Mumbai, compared with a database in Mumbai. Five sequential queries make that roughly 200-300 ms per request.

Get free Postgres in Mumbai

One free Postgres per account, 1 GB, no card, and not paused for inactivity. See how it compares in managed PostgreSQL in India.

Last updated: 14 November 2026: every free-tier limit re-checked against each provider’s own page; latency measured on 16 October 2026. If a provider has changed something we missed, write to us and we will correct it.

This guide lists the current prices, explains how Heroku bills, and works three bills through to the rupee amount on an Indian card. All figures are from Heroku’s dyno types documentation and add-on pages, checked on 14 October 2026.

Heroku pricing at a glance: every dyno tier

Except for Eco, every price below is the most you pay for one dyno running all month on the Common Runtime.