Inngest Has a Free API: The Event-Driven Platform That Turns Your Functions Into Reliable Background Jobs

#inngest #api #serverless #events

Background jobs are hard. You need queues, workers, retry logic, scheduling, and monitoring. Inngest replaces all of that with event-driven functions that run reliably — without managing any infrastructure.

What Is Inngest?

Inngest is a platform for running reliable background functions. You write TypeScript functions that respond to events, and Inngest handles queuing, retries, scheduling, concurrency, and step-level durability. No Redis, no Bull, no SQS.

The Free API

Inngest offers a generous free tier:

Free plan: 50,000 function runs/month
Event-driven: Functions triggered by events
Step functions: Multi-step workflows with automatic retries
Scheduling: Cron jobs built in
Concurrency control: Rate limiting per function
Fan-out: Trigger multiple functions from one event
Dashboard: Visual debugging and monitoring

Quick Start

Install Inngest:

npm install inngest

Define an event-driven function:

import { Inngest } from 'inngest';

const inngest = new Inngest({ id: 'my-app' });

// Function triggered by an event
export const processOrder = inngest.createFunction(
  { id: 'process-order' },
  { event: 'order/placed' },
  async ({ event, step }) => {
    // Step 1: Charge payment (auto-retried on failure)
    const charge = await step.run('charge-payment', async () => {
      return await stripe.charges.create({
        amount: event.data.amount,
        customer: event.data.customerId,
      });
    });

    // Step 2: Send confirmation email
    await step.run('send-email', async () => {
      await resend.emails.send({
        to: event.data.email,
        subject: 'Order Confirmed',
        html: orderConfirmationTemplate(charge),
      });
    });

    // Step 3: Wait 24 hours, then request review
    await step.sleep('wait-for-delivery', '24h');

    await step.run('request-review', async () => {
      await resend.emails.send({
        to: event.data.email,
        subject: 'How was your order?',
        html: reviewRequestTemplate(event.data),
      });
    });
  }
);

Send events:

// From your API handler
await inngest.send({
  name: 'order/placed',
  data: {
    orderId: 'ord_123',
    customerId: 'cus_456',
    email: 'john@example.com',
    amount: 4999,
  },
});

Scheduled functions (cron):

export const dailyReport = inngest.createFunction(
  { id: 'daily-report' },
  { cron: '0 9 * * *' },  // Every day at 9am
  async ({ step }) => {
    const metrics = await step.run('fetch-metrics', async () => {
      return await db.getDailyMetrics();
    });

    await step.run('send-report', async () => {
      await slack.postMessage({
        channel: '#metrics',
        text: formatDailyReport(metrics),
      });
    });
  }
);

Why Teams Choose Inngest

A marketplace app had a critical bug: when payment processing failed mid-order, they had no retry mechanism. Orders were charged but never fulfilled. After switching to Inngest step functions, each step retries independently — if the email step fails, it retries without re-charging the customer. They went from 5 lost orders per week to zero.

Who Is This For?

Backend developers needing reliable background jobs without queue infrastructure
Teams building multi-step workflows (onboarding, order processing)
Serverless developers wanting durable functions beyond request timeouts
Anyone tired of managing Redis/Bull/SQS for background jobs

Start Building Reliable Functions

Inngest turns your functions into reliable, observable workflows. Events in, reliable execution out — no infrastructure to manage.

Need help with event-driven architecture or background job systems? I build custom backend solutions — reach out to discuss your project.

Found this useful? I publish daily deep-dives into developer tools and APIs. Follow for more.

DEV Community