Deno Deploy Alternatives in 2026: Cloudflare Workers, Netlify, Supabase, Vercel and Val Town

Cloudflare Workers is the first place to evaluate among Deno Deploy alternatives: Deno names it as the migration path and says Deploy will operate for 6 more months. Choose Netlify for a site with Deno-based edge logic, Supabase Edge Functions for a database-backed API, Vercel Functions for a framework-led app, or Val Town for small scheduled jobs. If your app uses Deno KV, choose its replacement before choosing where the functions run.

Prices and documentation verified on 12 October 2026. This is a comparison of public pricing, runtime contracts and migration work, without signed-in deployment tests. The closure window comes from Deno's October 9 announcement.

Deno Deploy Alternatives at a Glance

Choose the destination that preserves your application's behavior with the fewest changes you will have to maintain. A TypeScript endpoint that calls an external database is a different migration from an app whose transactions, schedules and queue all live inside Deno Deploy.

The plan sources are Cloudflare, Netlify, Supabase, Vercel, Val Town, its billing FAQ, and DigitalOcean's VPS pricing. These are entry prices, not promises about your complete monthly bill.

What Deno Announced, and What the Timeline Means

Deno Deploy is closing; the Deno runtime has a separate maintenance window. In the announcement dated October 9, 2026, Ryan Dahl wrote:

Deno Deploy will continue operating for six months before shutting down.

The same announcement promises migration support for paying customers moving to Cloudflare Workers. It also commits to another year of monthly Deno runtime releases containing bug fixes and security updates, after which Deno will end its development of the runtime. The runtime remains open source. JSR, the JavaScript and TypeScript package registry, will continue operating with its infrastructure moving to Cloudflare. Read Deno's announcement.

Deno gives windows, not a calendar shutdown day. Do not turn the announcement into an invented deadline, and do not mistake the runtime's longer maintenance period for extra time on Deploy. A paying customer should use the migration support while planning the application and data move together.

1. Cloudflare Workers: The First Migration Path to Evaluate

Cloudflare Workers, a managed platform for running request handlers and background work, is the strongest default shortlist entry because Deno explicitly directs customers there. For a founder with a TypeScript API, an external database and a scheduled cleanup task, the main work is adapting the runtime boundary and deployment configuration. An app built around Deno KV needs a separate storage redesign. Choose Workers for the destination platform; budget explicitly for the Deno-specific parts that will not travel unchanged.

Best for: APIs, webhooks, cron jobs, queues and sites that benefit from managed infrastructure.
Standout: Deno's named migration path, with storage and scheduling services on the destination platform.
Pricing: Workers Free; Workers Paid has a $5 USD/month account minimum; Enterprise usage follows its contract.
Free trial: The ongoing Workers Free plan is the free evaluation option.
Migration effort: Low to medium for stateless handlers; high when KV transactions and queued work need redesign.

What changes in your TypeScript code

Workers runs the workerd runtime, not the Deno runtime. It does not provide the global Deno namespace. Standard web interfaces such as Request, Response and fetch give portable code a useful starting point, while Deno.serve, Deno.env, Deno.openKv and Deno.cron identify boundaries to replace. Node.js compatibility also covers a subset of APIs, so a package importing successfully during development is not sufficient evidence that its runtime dependencies will work. Workers runtime APIs.

Wrangler is Cloudflare's deployment command-line tool. Deno's own Wrangler tutorial shows how to keep Deno as the development toolchain: add npm:wrangler, generate Workers types, export a module with a fetch handler, and bundle through esbuild with the Deno plugin when you need Deno module resolution. Using Deno to build the upload does not make the deployed Worker a Deno process.

Move secrets and resource access into bindings, the configured handles that let a Worker reach its database, queue or environment values. Audit dependencies as well as application files: a utility can hide a filesystem call even when your route handler uses only web APIs. Cloudflare bindings.

Replace services by behavior

The critical distinction is Workers KV versus Deno KV. Workers KV favors frequent reads and relatively infrequent writes; cached reads can be stale. Do not use a name match to migrate inventory reservations, account balances or an atomic uniqueness check. How Workers KV works.

D1 is the SQL route: turn key prefixes and secondary indexes into a deliberate schema. Its batch API executes statements transactionally, but that does not translate a Deno optimistic check automatically. Durable Objects, which combine state with a coordinating compute instance, deserve a look when an entity needs serialized coordination, such as a room or account. D1 transactions, Durable Objects.

For scheduled work, Cron Triggers use a scheduled handler and UTC schedules. For deferred work, Queues supplies the messaging system. A schedule says when to start; a queue preserves work waiting to be processed. Replacing one does not replace the other. Static sites can use Workers Static Assets, keeping their generated files separate from dynamic request logic.

The price and the wall

Workers Free includes 100,000 requests per day and 10 ms of CPU per invocation. Paid includes 10 million requests and 30 million CPU milliseconds per month, then $0.30 per additional million requests and $0.02 per additional million CPU milliseconds. Database, queue and other product usage must also be costed. Current Workers pricing.

Bundle size alone is no longer a reason to buy Paid: Free and Paid both allow 64 MiB uncompressed, while memory remains 128 MB. Check the current limits and our bundle-size upgrade explanation. The broader Cloudflare review explains how the account's different products fit together.

1. 1

   Inventory the runtime boundary

   Find Deno namespace calls, URL imports, filesystem access, secrets, KV operations, schedules and queue consumers. Separate portable business logic from those adapters.

2. 2

   Build a Worker-shaped entrypoint

   Follow Deno's Wrangler tutorial: configure the module handler and generated Workers types, then set up the custom Deno-aware build if your imports require it. Keep the existing response contract while changing how the handler is invoked.

3. 3

   Provision state and triggers deliberately

   Choose the database before importing records. Add bindings, map schedules to Cron Triggers, and rewrite queue producers and consumers. Document what happens if a job is delivered again.

4. 4

   Rehearse before redirecting traffic

   Use local fixtures and a separate destination environment to compare status codes, headers, authentication and state changes. Deploying the code is only one checkpoint; data and background work must be ready for the same cutover.

2. Netlify: Best for Sites With Deno-Based Edge Logic

Netlify, a website deployment platform with Deno-based Edge Functions, fits a site whose dynamic work happens around incoming requests: localization, authentication checks, redirects or lightweight personalization. Keeping that logic beside the site's deployment previews can be more valuable than adopting a new infrastructure model. A stateless edge handler is a reasonable migration candidate; a queue-heavy backend requires more separation. Pick Netlify when the website is the product and edge logic supports it. Edge Functions overview.

Best for: Static sites and web applications with lightweight Deno-based request logic.
Standout: Edge Functions deployed with the site, including previews and rollbacks.
Pricing: Free $0 forever; Personal $9/month; Pro $20/month with unlimited members; Enterprise Custom.
Free trial: Free includes a 300-credit monthly limit.
Migration effort: Low to medium for a site and stateless edge logic; higher when storage, schedules and queue consumers must be separated.

The runtime stays familiar; the application contract changes

An Edge Function uses Netlify's handler and context. Review imports as well: Netlify documents a separate import-map file rather than the import map inside deno.json, and describes npm package support as beta. That is a concrete migration task for a project whose dependency resolution currently relies on Deno configuration. Edge Functions API.

The execution wall is 50 ms CPU per request, with a 40-second response-header timeout. Waiting for a remote service and transforming a large document consume different budgets. An authentication lookup may fit a lightweight edge design; CPU-heavy processing deserves a different execution path. Edge Function limits.

What replaces Deno KV, cron and queues

Use Netlify Blobs for suitable key-addressed content and Netlify Database, its Postgres service, when the application needs relational data and transactional updates. Blobs offers optional strong reads, but stronger reads alone do not reproduce Deno KV's atomic multi-key API. Preserve the business invariant, such as preventing duplicate usernames, in the replacement storage design.

Scheduled Functions are a separate Netlify Functions feature. Do not expect an Edge Function containing Deno.cron to acquire a managed schedule. Extract the task, configure its schedule, and review its runtime separately. If the old task consumes a Deno KV queue, identify the durable message store and the consumer explicitly; scheduling a function does not migrate queued messages.

For a founder with a content site and an hourly synchronization task, this separation is manageable: site delivery and personalization go to the web platform, while synchronization gets its own scheduled function and durable state. It is less attractive when most of the app consists of interdependent background workers.

Price the credits and the team

Personal includes 1,000 credits/month. Pro's credit tiers are 3,000 for $20, 5,000 for $33, 10,000 for $63, 15,000 for $95, and 20,000 for $126, per month. The higher tiers starting at 5,000 credits allow unused monthly credits to carry into the next billing cycle; the base tier does not. Netlify's current credit tiers.

Auto recharge is off by default. Personal can add 500 credits for $5 and Pro 1,500 for $10 when enabled. Exhausting the account's allowance without more credits can pause its projects, so a public launch needs a spending decision as well as a deployment decision. These current credit plans should not be confused with older Netlify seat-based pricing.

3. Supabase Edge Functions: Best for Database-Backed APIs

Supabase Edge Functions, TypeScript functions running on a Deno-compatible runtime, are the best fit when the migration is also a deliberate move to Postgres, a relational database. A subscription app that receives payment webhooks and updates customer records has a natural destination here. The familiar runtime reduces one category of change, while the database becomes the main design job. Choose Supabase when persistent application data drives the architecture. Functions documentation.

Best for: Webhooks and APIs that should live beside Postgres, authentication and file storage.
Standout: Deno-compatible functions integrated with a database platform.
Pricing: Free $0/month; Pro from $25/month; Team from $599/month; Enterprise Custom.
Free trial: Free includes 500,000 Edge Function invocations and a 500 MB database per project.
Migration effort: Medium for compatible handlers; high when Deno KV must become a relational schema with new transaction logic.

Move the data model as well as the endpoint

Replace Deno KV calls with Postgres access. A prefix such as a user's saved items becomes a queryable relationship; a uniqueness check becomes a database constraint or transaction. Avoid keeping a collection of opaque key strings merely to make the import look easier if every important query will immediately need to decode them.

For example, a payment handler may need to record an event and update an entitlement together. The acceptance criterion is that retries cannot grant the entitlement twice. A successful HTTP response from the new function does not prove that invariant survived the storage rewrite.

Supabase also provides Cron, which can run database work or invoke an Edge Function, and Queues, durable messaging backed by Postgres. Replace Deno.cron registration and Deno KV enqueue/consumer code with those services deliberately. Decide how messages are acknowledged and how a failed task becomes eligible for another attempt.

The runtime wall and the complete starting bill

Edge Functions allow 256 MB memory and 2 seconds of CPU per request. The worker wall-clock limit is 150 seconds on Free and 400 seconds on paid plans, but that longer lifetime does not enlarge the CPU budget. These are different limits, not interchangeable descriptions of a long-running worker. Function limits.

Pro and Team include 2 million function invocations, then charge $2 per additional million. Free permits 2 active projects and pauses inactive projects after 1 week. Paid plans include a $10/month compute credit that covers a Micro instance. Supabase pricing.

Supabase is a weaker destination for the site's static frontend. Its function limits document that serving HTML requires a custom domain; otherwise a text/html response is rewritten to text/plain. Keep the frontend hosting choice separate from the API decision.

4. Vercel Functions: Best When the Web Framework Drives the Move

Vercel Functions, managed server-side functions attached to a web deployment, fit an app where the frontend framework and release workflow are the main reason to switch. If a founder is already reorganizing the application around a Vercel-supported framework, moving API routes into that structure may be sensible. It is a less direct escape route for an otherwise unchanged Deno service. Choose Vercel for the app workflow, with an explicit runtime and storage port.

Best for: Framework-led web applications with API routes alongside the frontend.
Standout: A unified application deployment workflow with server-side functions.
Pricing: Hobby $0/month; Pro $20/month; Enterprise Custom.
Free trial: Pro advertises a trial; Hobby is restricted to personal, non-commercial use.
Migration effort: Medium for runtime and route adaptation; high when storage and background work also need replacement.

Decide whether you are porting or keeping a community runtime

Vercel lists Node.js among its supported runtimes and Deno as the community runtime vercel-deno. Those are different maintenance choices. For a deadline-driven move, assess the community integration's compatibility and ownership before making it the dependency that keeps production running. Otherwise, port the handler and dependencies to the supported runtime your framework uses. Vercel runtime documentation.

For Deno KV, choose a database and replace the API. Vercel's storage guide distinguishes Blob for files, Global Config for configuration and Marketplace databases for application data. A configuration store should not become the default home for transactional customer records merely because it looks like a convenient key-value interface.

Vercel Cron is a replacement for the schedule, not for Deno.cron code registration. Hobby permits a job to run once per day, with hourly scheduling precision; Pro supports a minimum interval of once per minute. A frequent synchronization job rules out Hobby on scheduling alone. Cron usage and pricing.

Vercel Queues is now available in beta on all plans, with durable topics, automatic retries and at-least-once delivery. That makes it a candidate for Deno KV queue work, but producers, consumers and acknowledgement behavior still need a rewrite. Treat the beta status as part of the decision if this queue is the only path to fulfilling a customer order.

The price changes when more people deploy

The Pro platform fee includes 1 deploying seat and $20 in monthly usage credit. Additional paid seats cost $20/month each; viewer seats are free. Usage beyond the credit and paid add-ons are separate. Pro billing details.

For a business leaving Deno Deploy, the free Hobby price is not the production budget. Start with the eligible commercial plan, then add the database and queue requirements. This prevents a cheap-looking migration from becoming an unexpected collection of separate bills.

5. Val Town: Best for Small APIs and Scheduled Jobs

Val Town, a hosted environment for small programs with HTTP, email and cron triggers, is a strong fit for the little service that does one useful job. Think of a webhook that updates an external system, an API used by an internal tool, or a scheduled digest. Its Deno runtime makes it relevant to this move, but the storage and trigger interfaces still differ. Choose Val Town when the project is a compact automation rather than a platform you need to operate. Val Town documentation.

Best for: Small APIs, webhook handlers, scheduled integrations and internal utilities.
Standout: Hosted code with built-in triggers and SQLite storage.
Pricing: Free $0; Pro $21/month billed yearly; Business starting from $167/month billed yearly; Enterprise Custom. The vendor FAQ lists monthly subscriptions at $25 for Pro and $200 for Business.
Free trial: Free is an ongoing plan, with no custom domains and no private vals.
Migration effort: Low for a stateless utility, medium for a small persistent job, high for a larger stateful application.

Those billing periods matter: the yearly-selected pricing page should not be presented as a cancel-any-month subscription at the same rate. Val Town's FAQ supplies the monthly-billing comparison and confirms its Deno runtime.

The migration is small only if the job is small

Move the handler into a val, Val Town's versioned app container, and map its invocation to an HTTP or cron trigger. For a job that only calls an external API and sends a digest, the durable state might be just the last item processed. That is much easier to reason about than a customer-facing app with multiple transactional entities and queue consumers.

Replace Deno KV with Val Town's per-val SQLite database where suitable, or retain an external database. Rewrite key lookups and atomic checks as database operations. Do not leave Deno.openKv pointing at the retiring hosted store and count the migration as finished.

For queued work, make the pending jobs visible in the design. A cron that periodically scans a job table is a possible application design, but you must implement claiming, retries and duplicate handling. It is not an automatic preservation of Deno KV queue behavior.

Frequency, privacy and duration decide the plan

Free's minimum cron interval is 15 minutes and its wall-clock limit is 1 minute per run. Pro lowers the interval to 1 minute and raises the run limit to 10 minutes; the pricing card also lists 10 custom domains and 2,000 private vals. Current pricing and limits.

A public daily digest might fit Free. A private integration or a job that must poll more often needs a different plan even if its traffic is tiny. Code privacy and endpoint access are also separate requirements: private source does not by itself specify who can call your HTTP endpoint.

Migration effort is low for a stateless utility with a simple trigger, medium when persistent job state must move, and high if you are trying to reproduce a larger application's runtime and data architecture inside it. Those are scope judgments, not estimates of elapsed hours.

6. Self-Hosted Deno: Best for Preserving Runtime Behavior

Deno on a virtual private server, or VPS, preserves the runtime while you take responsibility for hosting it. A container packages the runtime and application so they can be run on a host of your choosing. This is worth considering when filesystem access, Deno-specific APIs or long-lived process behavior dominate the porting work. Choose self-hosting when keeping the runtime saves more complexity than operating the server adds. Deno publishes official Docker guidance.

Best for: A Deno-heavy application whose owner can manage a server or container deployment.
Standout: Control over the runtime, filesystem and process lifecycle.
Pricing: The open-source runtime has no managed-hosting plan. As one host example, DigitalOcean lists a Basic Regular Droplet at $4.00/month, with 512 MiB RAM; its 1 GiB option is $6.00/month.
Free trial: DigitalOcean mentions promotional credits, but its pricing page does not offer an ongoing free Droplet tier.
Migration effort: Lower runtime rewrite effort, higher operating responsibility; hosted data still needs an export, import and recovery plan.

Those are listed VPS prices, not a sizing recommendation for every Deno app. Add backup storage, monitoring and your operating time to the decision. A server you already own may avoid a new hosting subscription while still creating maintenance work.

What happens to Deno KV and cron

Deno KV can use a persistent local database path, with SQLite underneath in the CLI. This can retain more of the KV API than a move to another vendor's storage service. It does not copy your hosted records, recreate distributed hosting or make an ephemeral container filesystem durable. Export the data, import it deliberately, mount persistent storage and prove that you can restore a backup. Deno KV documentation.

The same distinction applies to scheduling. In the CLI, Deno.cron keeps execution state in memory, with an independent set of tasks in each process. If you run multiple application replicas, you must decide which one owns a scheduled job or how they coordinate. Keeping the API call unchanged does not preserve Deploy's managed scheduling service. Deno cron behavior.

For a small single-server app, that operational scope may be acceptable. For a business that needs redundant infrastructure and nobody wants to own backups, patching or recovery, a small VPS bill can be an expensive distraction.

workerd and celld are a different self-host route

Cloudflare's announcement names workerd and celld as self-hosting options available today. These use the Workers programming model, so they belong after a Workers-style port, not in a promise to run all existing Deno code unchanged. Cloudflare also acknowledges that standalone workerd's Durable Objects implementation has a single-instance scaling gap and describes merging work and ideas from celld into workerd. Cloudflare's announcement.

Do not price either as a new managed subscription with an invented free tier. Your budget is the infrastructure and operations you supply. For a team under migration pressure, evaluate the capabilities available now and the recovery plan you can operate; future integration work is not a substitute for those decisions.

Self-hosted Deno can be a bridge, but its longer-term runtime maintenance plan also matters given Deno's announced support window.

Choose by What Your Project Runs

The decision flips when the hardest thing to move is state rather than code. Rate effort by the changes you can identify: low means a handler or build adaptation with external state unchanged; medium adds a runtime boundary or storage API rewrite; high adds transaction redesign, queued-work transfer or new operating responsibilities. A small app can still be a high-effort migration if its correctness depends on those behaviors.

For TypeScript functions without Deno-specific APIs, start with Workers. Preserve the request and response contract, then adapt the entrypoint and deployment. Netlify becomes more attractive when those functions modify a site's requests; Supabase becomes more attractive when they mostly operate on its database. Vercel wins when the surrounding framework is already the reason for the move. A stateless handler is usually the lowest-effort case across these destinations.

For Deno KV, choose the storage model first. Read-heavy content may suit Workers KV or Netlify Blobs. Transactional records point toward D1, Postgres or another database designed around the required invariant. Coordination may point toward Durable Objects. A small utility may need only Val Town SQLite. Self-hosted local KV can preserve more code but moves durability and recovery onto you. Treat any hosted KV migration as at least a medium scope until its transaction and index inventory proves otherwise.

For cron, compare the execution contract. A daily report and a frequent poller have different plan requirements. Workers Cron Triggers is the first managed route to evaluate; Val Town is attractive for a compact job; Supabase Cron fits database maintenance; Netlify Scheduled Functions fits work associated with a site. Vercel Hobby's daily restriction rules it out for frequent jobs. Re-registering a schedule is small work; preventing overlapping side effects may not be.

For queues, move the backlog and the consumer together. Cloudflare Queues and Supabase Queues are explicit destinations; Vercel Queues adds a beta option. The migration includes message identity, retries, acknowledgement and the jobs already waiting. A timer alone is not a replacement. This is high scope when queued work represents paid customer obligations.

For static sites, move the generated output before porting unnecessary server code. Workers Static Assets and Netlify are direct candidates; Vercel belongs on the shortlist when the site framework benefits from its workflow. Check redirects, headers, forms, authentication and dynamic routes separately. A plain static output is a lower-effort move than a site that renders personalized responses on every request.

Move Deno KV Without Losing Application Behavior

A code deployment and a data migration have different success criteria. The code succeeds when it answers correctly; the migration succeeds when the destination preserves the records and rules that make those answers correct.

Before exporting, inventory the KV features you use: typed compound keys, prefix scans, expiration, secondary indexes, optimistic version checks, atomic updates and watchers. Deno's KV guide shows why a collection of keys can encode more application behavior than a simple object dump suggests.

A username index is a useful example. If the app stores a user record and a username-to-user lookup, copying both records is not enough. The new write path must preserve their relationship and reject conflicting updates. Similarly, a timestamp that used to expire a session needs an explicit destination policy; importing the value without that behavior can leave it valid too long.

For queues, keep a separate list of pending, completed and failed work where the source exposes it. Decide whether to drain the old consumer before switching or transfer jobs with identifiers that make replay safe. Idempotency means repeating a task does not repeat its business effect. It is the property that prevents a retried receipt job from sending multiple receipts or a repeated fulfillment message from creating duplicate work.

1. 1

   Copy with a defined write boundary

   Back up the source and decide how writes are handled during the copy. A short write pause may suit a small application; a more complex synchronization approach needs reconciliation. Do not let concurrent changes silently disappear between export and cutover.

2. 2

   Verify records and behavior

   Compare counts by entity type, representative values and key encodings. Exercise duplicate submissions, conflicting updates, expirations and missing records using controlled fixtures. Check the expected business outcome, not just whether the new API returned success.

3. 3

   Switch traffic and job ownership together

   Redirect requests only when the destination state is ready. Disable or hand over old schedules and consumers so both platforms do not perform the same side effect. Recreate secrets and webhook destinations deliberately.

4. 4

   Watch and retain a usable rollback path

   Monitor errors, failed jobs and business events after the change. Keep the source backup. If the destination has accepted new writes, rollback needs a data reconciliation plan, not merely a DNS reversal.

Your next working session should produce an inventory and a destination decision for the hardest stateful operation. Port that operation before polishing the rest of the migration. It will expose more risk than moving another stateless health endpoint.

How These Were Picked

These routes were selected for the workloads in a Deno Deploy application: HTTP functions, persistent state, scheduled tasks, queued work and static output. Cloudflare comes first because Deno names it as the migration path. Netlify, Supabase and Val Town earn their places through Deno-based execution and distinct application fits; Vercel through the web deployment workflow; self-hosting through runtime control.

Pricing and capabilities were checked against the makers' public pages on 12 October 2026. Effort ratings describe the changes required by those documented interfaces. They are not measured migration times, load-test results or claims of a signed-in trial. General-purpose cloud services were left outside the shortlist because adding more provider names would not resolve the central runtime, state and job-ownership decisions.

The Ones to Avoid for This Move

Avoid Workers KV as a mechanical substitute for transactional Deno KV. Choose it only when its read and write behavior fits the data. A cheap storage line is not compensation for broken consistency assumptions.

Avoid Netlify Edge Functions for CPU-heavy background processing. Its edge request budget is a useful boundary, not a challenge to work around by hoping a paid plan changes the execution model.

Avoid Vercel Hobby for a commercial production app. The pricing page restricts it to personal, non-commercial use. Its cron limitations also make it the wrong free-plan comparison for frequent jobs.

Avoid Val Town Free for source that must remain private. Plan eligibility matters before traffic volume. Avoid Supabase Edge Functions as the default replacement for a conventional static site, too; choose frontend hosting deliberately.

Avoid self-hosting without a recovery owner. Running the process is the easy part of the choice. Someone must be able to restore data, restart services and explain which scheduler is responsible after an outage.

Questions Before You Move

When does Deno Deploy shut down?

The announcement gives a six-month operating window rather than a calendar day. Use that stated window; do not substitute the longer runtime-maintenance period.

Can I keep Deno when I leave Deno Deploy?

Yes. Netlify Edge Functions, Supabase Edge Functions and Val Town offer Deno-based or Deno-compatible execution, while a VPS or container lets you run Deno yourself. Each managed platform has its own API and limits. Keeping Deno does not automatically preserve the hosted KV database, schedules or queue.

Can I move Deno KV straight into Cloudflare KV?

Only if you also adapt the API and confirm that the application's consistency requirements fit Workers KV. Deno KV atomic checks, transactions, indexes and watchers need explicit replacements. For transactional records, evaluate D1 or another database; for coordinated per-entity state, consider Durable Objects.

Which free plan can run my cron job?

Match frequency, execution budget, source privacy and commercial eligibility first. Val Town Free has a 15-minute minimum interval and a 1-minute run limit. Vercel Hobby is restricted to daily jobs and personal non-commercial use. Workers Free has a tight CPU budget; Netlify and Supabase have their own shared plan allowances. A free scheduler is not proof that the whole job fits free.