For Fly.io
Free Tier

Fly.io Cron Jobs
Made Simple

Run reliable scheduled tasks on Fly.io across all regions without infrastructure complexity. Get global distributed cron jobs, edge coordination, and built-in monitoring for your Fly applications.

Deploy to Fly.ioView Fly.io Docs
Coordinated across all Fly.io regions:
🇺🇸US East
🇪🇺EU West
🇯🇵Asia
🇦🇺Sydney
Trusted by developers
Works globally
Works with Fly machines globally
package main

import (
    "context"
    "fmt"
    "time"
    schedo "github.com/useschedo/golang"
    "github.com/useschedo/golang/option"
)

func main() {
  client := schedo.NewClient(option.WithAPIKey("key"))

  // Define a new job
  client.DefineJob(
    "example_job",
    "0 9 * * *", // Run every day at 9 AM
    func(ctx *schedo.JobExecutionContext) (string, error) {
      err := processData()
      if err != nil {
        return "", err
      }

      return "Job completed successfully", nil
    },
  )

  client.Start()
}
✅ Global coordination • ✅ Edge failover • ✅ Regional monitoring

The Fly.io Cron Job Challenge

Running scheduled tasks on Fly.io's global edge network requires careful coordination to prevent duplicates and ensure reliability across regions.

Common Fly.io Cron Problems

Running separate Fly apps just for cron job coordination
Using Redis instances to prevent duplicate executions
Complex webhook triggers and queue management
Multiple regions running duplicate scheduled tasks
No built-in coordination between Fly machines
Difficulty monitoring scheduled tasks across regions

Schedo.dev Solutions

Single execution guarantee across all Fly regions
No additional Fly apps or Redis needed for coordination
Built-in webhook jobs for sleeping machine triggers
Works within your existing app context
Comprehensive monitoring and error handling
Platform-agnostic solution with easy migration

Built for Fly.io's Global Edge

Every feature optimized for Fly.io's distributed architecture and global reach

Global Coordination

No need for separate Fly apps or Redis instances. Single execution guarantee across all regions without additional infrastructure.

Zero Infrastructure

Replace your custom coordination setups with a simple SDK integration. No additional Fly apps or databases required.

App Context Execution

Jobs run within your existing Fly app context, not in separate containers. Access your databases and services directly.

Webhook Jobs

Perfect for triggering sleeping Fly machines or stateless apps. Schedule HTTP calls to any endpoint globally.

Built-in Reliability

Automatic retries, error handling, and comprehensive monitoring. No need to build your own coordination logic.

Complete Monitoring

Real-time execution logs, performance metrics, and failure alerts. Track job performance across all regions.

Easy Fly.io Integration

Works seamlessly with any Fly.io deployment - from full-stack apps to microservices

Fly.ioNode.js on Fly.IO
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const schedo = new SchedoSDK(
  withApiKey(process.env.SCHEDO_API_KEY)
);

await schedo.defineJob(
  "cleanup_task",
  ExecutionInterval.Hourly,
  async (ctx) => {
    await cleanupFiles();
    return { success: true };
  }
);

schedo.start();
Fly.ioGo on Fly.IO
package main

import (
    "context"
    "fmt"
    "time"
    schedo "github.com/useschedo/golang"
    "github.com/useschedo/golang/option"
)

func main() {
  client := schedo.NewClient(option.WithAPIKey("key"))

  // Define a new job
  client.DefineJob(
    "example_job",
    "0 9 * * *", // Run every day at 9 AM
    func(ctx *schedo.JobExecutionContext) (string, error) {
      err := processData()
      if err != nil {
        return "", err
      }

      return "Job completed successfully", nil
    },
  )

  client.Start()
}

Fly.io Frequently Asked Questions

Everything you need to know about running cron jobs on Fly.io with Schedo.dev

Schedo.dev uses distributed coordination to ensure each job runs exactly once across all your application instances. Our system maintains a global job state that prevents race conditions and duplicate executions, even in multi-region deployments.
If an instance executing a job goes down, Schedo.dev automatically detects the failure and reassigns the job to a healthy instance. This ensures your scheduled tasks continue running without manual intervention.
Yes! Schedo.dev provides comprehensive monitoring including real-time execution logs, performance metrics, failure alerts, and detailed job history. You can track success rates, execution times, and get notified of any issues.
Schedo.dev offers a generous free tier for small projects. Paid plans are based on the number of job executions per month. Check our pricing page for detailed information.
Schedo.dev is region-aware and coordinates jobs across all your Fly.io regions automatically. Jobs run exactly once globally, regardless of how many regions your app is deployed to. Our system understands Fly's edge network topology.
Schedo.dev handles Fly's machine lifecycle gracefully. When machines scale to zero, jobs are automatically coordinated through our external infrastructure. When machines spin back up, they seamlessly rejoin the coordination without missing scheduled executions.
Yes! While jobs run once globally by default, you can configure region-specific jobs if needed. This is useful for region-specific data processing or compliance requirements.
Integration is simple - just add your Schedo API key to your environment variables in fly.toml and include the scheduler initialization in your app startup. No special Fly configuration required.
Absolutely! Your scheduled jobs can access all your Fly.io resources including Fly Postgres, Fly Redis, and any other services. Schedo.dev doesn't interfere with your existing Fly infrastructure.

Still have questions?

Contact our support team

Ready to Scale Your Fly.io Cron Jobs Globally?

Join hundreds of developers running reliable scheduled tasks across Fly.io's global edge network. Start coordinating your jobs worldwide in minutes.

Deploy Globally - Start FreeView Documentation