Why You Need a Background Task Handler

If you’ve got scheduled jobs, long-running tasks, or anything that should run asynchronously without blocking your API, you need a background task handler. Whether it’s sending notifications, cleaning up old data, or running periodic reports, offloading tasks to a separate process keeps your app snappy and responsive.

We’re going to build a robust, general-purpose background task handler in Go using github.com/robfig/cron. This example is stripped down to essentials, but it’ll be flexible enough for most use cases.

Core Components

1. The Job Struct

Each background task needs:

• A schedule (using cron syntax).
• A handler function that runs the task.

Here’s our Job struct:

package background

type Job struct {
    Schedule string
    Handler  func()
}

This keeps things simple—each job just needs a schedule string (like “0/5 * * * * *” for every 5 seconds) and a function to execute.

2. Job Scheduler

We need something to register jobs, handle failures, and execute tasks at the right time. Here’s the core scheduler:

package background

import (
    "github.com/robfig/cron/v3"
    "log"
)

// Map of job names to their corresponding Job struct
var jobSchedules = map[string]Job{}

// RegisterJob adds a job to the scheduler
func RegisterJob(name string, schedule string, handler func()) {
    jobSchedules[name] = Job{Schedule: schedule, Handler: handler}
}

// Initialize starts the cron scheduler and registers jobs
func Initialize() {
c := cron.New()

	for name, job := range jobSchedules {
		_, err := c.AddFunc(job.Schedule, job.Handler)
		if err != nil {
			log.Printf("Failed to schedule job: %s, error: %v", name, err)
		} else {
			log.Printf("Scheduled job: %s", name)
		}
	}

	c.Start()
}

Breakdown:

1. jobSchedules: Stores registered jobs.
2. RegisterJob(): Adds new jobs to the schedule dynamically.
3. Initialize(): Loops through all registered jobs and schedules them.

Now, we have a dynamic scheduler where tasks can be added at runtime.

3. Example Job: Cleaning Up Old Data

Let’s add a sample job that cleans up stale records:

package background

import (
    "log"
    "time"
)

// CleanUpOldRecords deletes records older than 30 days
func CleanUpOldRecords() {
    log.Println("Starting database cleanup...")
    // Simulate cleanup work
    time.Sleep(2 * time.Second)
    log.Println("Old records deleted successfully.")
}

func init() {
    RegisterJob("CleanUpOldRecords", "0 0 * * *", CleanUpOldRecords) // Runs daily at midnight
}

This registers the cleanup job to run every day at midnight.

4. Main Function: Putting It All Together

We need to initialize our scheduler when the app starts:

package main

import (
    "log"
    "time"
	"yourapp/background"
)

func main() {
    log.Println("Starting background job scheduler...")
    background.Initialize()

	// Keep the main thread alive (cron runs in a goroutine)
	for {
		time.Sleep(10 * time.Second)
	}
}

Why This Approach?

• Lightweight – No extra dependencies beyond cron.
• Flexible – Add or remove jobs dynamically.
• Fault-tolerant – Jobs are independent, failures don’t crash the scheduler.
• Scalable – Works well in microservices or monoliths.

For more complex needs (like job queuing or distributed task execution), consider tools like Celery, Kafka, or AWS SQS. But for small-to-medium background jobs, this setup works great.