Stop Waiting on Backend: Schedule API Calls Without a Ticket

Your backend team has a 3-week sprint backlog. You need a simple thing: send a reminder email 24 hours after a user signs up. Or expire a promo code after 7 days. Or retry a failed webhook.

You file a ticket. It gets prioritized behind the payment refactor, the database migration, and three bugs from last sprint. Your feature sits in the backlog for weeks.

Here’s the thing: you don’t need backend to build this. If your app can make an HTTP request, you already have everything you need.

The Pattern Backend Would Build

If you asked backend to implement “send a reminder email 24 hours after signup,” here’s what they’d scope:

  1. Set up a message queue (Redis, RabbitMQ, or SQS)
  2. Create a worker service to process the queue
  3. Write a job scheduler with delay support
  4. Implement retry logic with exponential backoff
  5. Add monitoring and alerting for failed jobs
  6. Deploy and maintain the worker infrastructure
  7. Write tests for all of the above

That’s why it’s a 2-week estimate for a “simple” delayed email. They’re not wrong — that’s genuinely what it takes to build it properly.

But you don’t have to build it. You can rent it.

What You Can Do Right Now

// After user signs up, schedule a reminder
await fetch(
  `https://zeplo.to/https://your-app.com/api/send-reminder?_delay=86400&_retry=3&_token=${ZEPLO_TOKEN}`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      userId: user.id,
      email: user.email,
      template: 'onboarding-day-1',
    }),
  }
);

That’s the entire implementation. No queue. No worker. No infra ticket. Zeplo holds the request for 24 hours (86,400 seconds), then POSTs to your endpoint. If it fails, it retries 3 times.

Your endpoint (/api/send-reminder) is a normal API route — the same kind you already build every day. It receives JSON, sends an email, returns 200.

Things You Can Unblock Today

“We need to send onboarding emails on a drip schedule”

// After signup, schedule the entire drip sequence
const drip = [
  { delay: 3600, template: 'welcome' },           // 1 hour
  { delay: 86400, template: 'getting-started' },   // Day 1
  { delay: 259200, template: 'pro-tips' },          // Day 3
  { delay: 604800, template: 'check-in' },          // Week 1
];

for (const step of drip) {
  await fetch(
    `https://zeplo.to/${APP_URL}/api/drip-email?_delay=${step.delay}&_retry=3&_token=${TOKEN}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ userId, template: step.template }),
    }
  );
}

“The third-party API keeps failing and we need retry logic”

// Instead of building retry infrastructure, just proxy through Zeplo
await fetch(
  `https://zeplo.to/https://api.partner.com/sync?_retry=5&_token=${TOKEN}`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${PARTNER_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload),
  }
);

“We need a daily report but backend can’t prioritize the cron job”

// Set up once — runs every weekday at 9am UTC
await fetch(
  `https://zeplo.to/${APP_URL}/api/daily-report?_cron=0|9|*|*|1-5&_retry=3&_token=${TOKEN}`,
  { method: 'POST' }
);

“Promo codes should auto-expire but we don’t have a scheduler”

// When creating a promo, schedule its expiration
await fetch(
  `https://zeplo.to/${APP_URL}/api/expire-promo?_delay=${7 * 86400}&_retry=2&_token=${TOKEN}`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ promoId: promo.id }),
  }
);

“We need to sync data between systems but it’s not reliable”

// Sync CRM when a deal closes — retry if Salesforce is flaky
await fetch(
  `https://zeplo.to/https://your-app.com/api/sync-crm?_retry=5&_token=${TOKEN}`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ dealId, status: 'closed-won', amount }),
  }
);

“But Won’t Backend Be Mad?”

No. Good backend engineers love when the team unblocks themselves without adding technical debt. Here’s why this isn’t a hack:

It’s just HTTP. Your endpoints are normal API routes. If you ever want to move to a “proper” queue later, the endpoints don’t change — you just swap the caller.

It’s observable. Every request is logged in the Zeplo dashboard with full request/response details. Backend can see exactly what’s running, what failed, and why.

It reduces their backlog. Every “schedule a thing” ticket that doesn’t need custom infrastructure is time they can spend on the payment refactor that actually needs their expertise.

There’s nothing to maintain. No Redis to monitor, no workers to restart at 3am, no dead letter queues to drain.

How to Pitch This to Your Team

“I need to send emails on a delay and retry failed API calls. Instead of building queue infrastructure, I want to use a managed service that’s just HTTP. It costs $39/month, takes 5 minutes to set up, and I can implement it myself without backend changes. Here’s a link to the dashboard so you can see what’s running.”

If they push back, show them the alternative: a 2-week sprint to set up Redis, BullMQ, a worker service, monitoring, and deployment. For something that’s already solved.

Getting Started

  1. Sign up — free tier includes 500 requests/month
  2. Add ZEPLO_TOKEN to your environment variables
  3. Use fetch() to schedule your first delayed request

No dependencies. No SDK. No infrastructure. No ticket required.

The backend team can review it in their next sprint if they want. But your feature ships today.

Zeplo is a managed HTTP queue. Delay, retry, and schedule API calls without backend infrastructure. Start free →

Return to Blog