DEV Community: Angel Garrett

Inngest Overview & Development Guide

Angel Garrett — Tue, 20 May 2025 02:42:34 +0000

What is Inngest?

Inngest is a developer-first, event-driven background job platform that enables building durable, serverless workflows using plain JavaScript/TypeScript functions. It provides powerful primitives like retries, delays, branching logic, and observability—without needing to manage infrastructure or complex orchestration systems.

⚙️Core Concepts

Events

Events are payloads that describe something that happened (e.g. user.signed_up, order.completed).

They are the triggers for Inngest functions.

{
  "name": "user.signed_up",
  "data": {
    "userId": "abc123",
    "email": "angel@example.com"
  }
}

Functions

Functions are units of work that respond to specific events.

Functions can contain multiple steps (via step.run) and are durable—they persist state across failures and can resume on retry.

export const sendWelcomeEmail = inngest.createFunction(
  { id: "welcome-email" },
  { event: "user.signed_up" },
  async ({ event, step }) => {
    await step.run("send email", async () => {
      await emailClient.sendWelcome(event.data.email);
    });
  }
);

Steps

Steps are atomic operations within a function.

Each step:

Is automatically retried on failure.
Persists its result (won’t re-run unless logic changes).
Can be delayed or run conditionally.

await step.sleep("wait 2 minutes", "2m"); // Delay

Serve

You expose your Inngest functions through a server (Next.js, Express, etc.) so Inngest can call them.

// Next.js
export default serve(inngest, [sendWelcomeEmail, ...moreFunctions]);

Architecture Overview

[ App/API ] --> emits events
          \
           --> [ Inngest Platform ] -- invokes --> [ Inngest Functions (hosted in your app) ]
                                                    ↳ with retry, steps, observability, etc.

Typical Use Cases

Use Case	Event	Function Descriptiion
Welcome Email	`user.signed_up`	Sends email and tracks signup source
Order Processing	`order.placed`	Orchestrates billing, stock check, and fulfillment
Retry Failed Webhooks	`webhook.failed`	Re-attempts delivery using exponential backoff
Scheduled Reports	`daily.report.ready`	Sends Slack summary of daily data
Wait-based Workflows	`payment.initiated`	Wait 1hr, then confirm payment

Local Development Workflow
Install CLI

npm install -g inngest-cli

Start Dev Server

inngest dev

Watches your functions
Starts a local UI on http://localhost:8288
Proxies events to your local API (e.g. /api/inngest)

Send Events for Testing

inngest send --name user.signed_up --data '{"email": "test@site.com"}'

Or use the Inngest Dev UI to manually craft and send events.

Advanced Function Capabilities

Step Dependencies and Branching

await step.run("check account", async () => {
  const account = await db.getAccount(event.data.userId);
  if (!account.isActive) throw new Error("Inactive user");
});

Parallel Execution

const [emailResult, analyticsResult] = await Promise.all([
  step.run("send email", sendEmail),
  step.run("track analytics", trackAnalytics)
]);

Conditional Steps

if (event.data.plan === "premium") {
  await step.run("provision premium", provisionPremiumFeatures);
}

Scheduling / Delays

await step.sleep("wait 24 hours", "24h");
await step.run("send reminder", sendReminderEmail);

Integration Patterns

From Backend Services

await inngest.send({
  name: "user.signed_up",
  data: { userId: "123", email: "test@example.com" }
});

From Frontend (via REST Proxy)

Create an API route to relay frontend events to Inngest.

// POST /api/events
const { name, data } = req.body;
await inngest.send({ name, data });

Error Handling & Observability

Each step is retried automatically on failure (configurable).
Function logs and run history are visible in the Inngest UI.
Use console.log() inside functions to view logs in real time.
Catch and throw specific errors to control retry behavior.

throw new InngestError("Custom failure", { retry: false });

☁️ Deployment Tips

In Next.js, deploy your API route (/api/inngest) to platforms like Vercel or AWS Lambda.
Functions are invoked over HTTP by the Inngest platform—no need to keep them always running.
Separate dev/staging/prod apps in the Inngest dashboard to isolate events.

🛠 Best Practices

Use clear event naming: object.action (e.g. user.created, checkout.completed)
Use step names that describe the action clearly for observability.
Treat steps like checkpoints: return useful data and avoid side-effects in raw function body.
Keep functions single-purpose—break out business logic into utilities where possible.
Enable function versioning via unique IDs or suffixes to maintain traceability.

Getting Started with the AWS Rekognition API

Angel Garrett — Mon, 19 May 2025 19:02:17 +0000

A Developer's Guide

Computer vision made easy with AWS Rekognition.

Amazon Rekognition is a powerful image and video analysis service provided by AWS. With just a few lines of code, you can analyze faces, detect objects, read text, and even identify unsafe content.

In this post, I’ll walk you through the basics of integrating Rekognition into your app using the AWS SDK. Whether you're building a photo moderation system or facial recognition features, this guide will help you get started quickly.

Prerequisites

Before diving in, make sure you have the following:

An AWS account
AWS credentials configured (~/.aws/credentials or IAM role if using EC2/Lambda)
AWS SDK installed (I'll use Python’s boto3, but the logic is similar in other SDKs)
An image file to test with

Installing `boto3`

pip install boto3

Setting Up Credentials

Ensure your credentials are properly configured. For example:

# ~/.aws/credentials
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY

Or set them as environment variables:

export AWS_ACCESS_KEY_ID=your-access-key
export AWS_SECRET_ACCESS_KEY=your-secret-key

Using Rekognition to Detect Labels

Label detection identifies objects, people, text, scenes, and activities in an image.

import boto3

client = boto3.client('rekognition')

with open('image.jpg', 'rb') as image:
    response = client.detect_labels(Image={'Bytes': image.read()}, MaxLabels=10, MinConfidence=80)

for label in response['Labels']:
    print(f"{label['Name']} - {label['Confidence']:.2f}%")

Detecting Faces

Rekognition can detect faces and even return landmarks like eyes and nose positions.

with open('face.jpg', 'rb') as image:
    response = client.detect_faces(Image={'Bytes': image.read()}, Attributes=['ALL'])

for face in response['FaceDetails']:
    print(f"Age Range: {face['AgeRange']}")
    print(f"Smile: {face['Smile']['Value']}")
    print(f"Emotions: {[e['Type'] for e in face['Emotions']]}")

Text Detection

You can also extract text from images, similar to OCR.

with open('text_image.jpg', 'rb') as image:
    response = client.detect_text(Image={'Bytes': image.read()})

for text in response['TextDetections']:
    print(f"Detected: {text['DetectedText']} - Type: {text['Type']}")

Content Moderation

Useful for platforms where user-generated content needs filtering.

with open('moderation.jpg', 'rb') as image:
    response = client.detect_moderation_labels(Image={'Bytes': image.read()}, MinConfidence=80)

for label in response['ModerationLabels']:
    print(f"{label['Name']} - Confidence: {label['Confidence']:.2f}")

Comparing Faces

Compare faces between two images, often used for verification.

source_img = open('source.jpg', 'rb').read()
target_img = open('target.jpg', 'rb').read()

response = client.compare_faces(SourceImage={'Bytes': source_img},
                                TargetImage={'Bytes': target_img},
                                SimilarityThreshold=90)

for match in response['FaceMatches']:
    print(f"Similarity: {match['Similarity']:.2f}%")

Pricing

Rekognition offers a free tier for the first 12 months with:

5,000 images for label and face analysis

1,000 images for moderation

After that, pricing is based on per-image or per-second analysis.

Tips for Production

Store and reference images via S3 for better performance and scalability.
Always handle exceptions (botocore.exceptions.ClientError) for more resilient code.
Monitor API usage with AWS CloudWatch.
Use IAM roles with least privilege for security.

Final Thoughts

AWS Rekognition abstracts away the complexity of computer vision. Whether you’re adding face detection to a photo app or moderating uploaded content, Rekognition offers a reliable and scalable solution.