RUNZA

Run background jobs without Redis or workers

Runza lets you run queues, delayed jobs and scheduled tasks without running your own job system.
  • Send a job via API.
  • Runza stores it.
  • Runza calls your backend when it's time.
No Redis
No workers
No cron
No queue libraries

Built for small SaaS and integrations.

Join waitlist
Background jobs are still more complex
than they should be
Even for simple async tasks you often need:

  • Redis
  • Queue library
  • Worker process
  • Cron jobs
  • Retries
  • Locks
  • Monitoring
For small apps this is often more infrastructure
than the app itself.

Every project starts simple

Then you need retries.
Then scheduling.
Then a worker loop.
Then a task table.
Then locking.

And suddenly you have a job system.

Run jobs outside your app
With Runza you don't need a worker process and you don't need a queue inside your code.
  • Send a job via API.
  • Runza stores it.
  • Runza executes it later.
  • Your backend receives a callback.
Your app stays simple.
How Runza works
  • Send a job via API: POST /jobs
  • Runza stores the job, handles delay, retries and scheduling
  • Runza calls your backend via HTTP callback
Use cases
  • Send emails later
  • Retry webhooks
  • Scheduled tasks
  • Long API calls
  • Background processing
  • Queue for SaaS jobs
  • Automation and bots
  • Internal tools
  • ...and anything that shouldn't run
    inside the request
Your app stays simple.
Typical setup:
App → Redis → Worker → Retry → Cron → Logs
With Runza:
App → Runza → Callback
Built for small backends
Runza works well for:
  • SaaS apps
  • Bots
  • Integrations
  • Webhooks
  • Side projects
  • Internal tools
Works best when you need async without heavy infrastructure
Not a workflow engine.
Not a queue library.
Just a simple external job runner.
Your app stays simple.
Runza API
Run background jobs without Redis, workers or cron.
Your App
│
│ enqueue job / webhook / schedule
▼
Runza
│
├ Queue
├ Scheduler
├ Retries
├ Logs
│
▼
Worker URL
│
▼
Your Backend

1. Create a Queue

Create a queue that will process email jobs: 
POST /v1/queues
Authorization: Bearer YOUR_RUNZA_API_KEY

{
  "name": "emails",
  "worker_url": "https://api.myapp.com/jobs/email"
}
Response:
{
  "id": "q_emails",
  "name": "emails"
}

2. Send a job

Enqueue a background job: 
POST /v1/jobs
Authorization: Bearer YOUR_RUNZA_API_KEY

{
  "queue": "emails",
  "payload": {
    "user_id": 42,
    "template": "welcome"
  }
}

Response:

{
  "job_id": "job_123",
  "status": "queued"
}

3. Worker endpoint

Runza calls your backend when it's time to run the job: 
POST https://api.myapp.com/jobs/email

{
  "job_id": "job_123",
  "payload": {
    "user_id": 42,
    "template": "welcome"
  },
  "retry": 0
}
Your backend processes the job. Example in Go: 
func EmailJob(w http.ResponseWriter, r *http.Request) {
  var req struct {
    JobID string `json:"job_id"`
    Payload map[string]interface{} `json:"payload"`
  }

  json.NewDecoder(r.Body).Decode(&req)

  userID := req.Payload["user_id"]

  sendWelcomeEmail(userID)

  w.WriteHeader(http.StatusOK)
}
If the request fails → Runza retries automatically.

4. Schedule jobs

Run jobs on a schedule:
POST /v1/schedules
Authorization: Bearer YOUR_RUNZA_API_KEY

{
  "queue": "maintenance",
  "cron": "0 * * * *",
  "payload": {
    "task": "cleanup"
  }
}
Runza will run the job every hour.
No cron needed.

5. Webhook queue

Use Runza as a webhook buffer.
Send webhook to Runza: 
POST /hook/emails
Runza:
- stores job
- retries on failure
- calls worker
- logs result

Perfect for:
- Stripe webhooks
- Telegram bots
- GitHub webhooks
- integrations
- AI jobs

6. What Runza replaces

Without Runza you need:
- Redis
- queue library
- workers
- cron
- retries
- logging
- monitoring

With Runza:
POST /jobs
Done. No Redis, workers or cron.

I'm building Runza now. Join if you'd use it.