Building Metrics with TimescaleDB
Darwin Wu11/29/2023
How we built better observability into Inngest
Python errors as values: Comparing useful patterns from Go and Rust
Aaron Harper11/8/2023
Safer error handling, inspired by Go and Rust
Your multi-tenant AI platform fails without flow control
Lauren Craigie5/27/2026
If you're building a platform where every customer request will hit the same OpenAI bill, you need the ability to slice and shape concurrency at a per-tenant level.
Accidentally Quadratic: Evaluating trillions of event matches in real-time
Tony Holdstock-Brown5/15/2024
Building the expression engine that powers ephemeral event matching.
When a queue isn't enough
Lauren Craigie3/25/2026
Queuing and durable execution are two layers of the same problem. In this post we’ll look at solutions dedicated to each, and when each are most appropriate for what you’re building.
Node.js worker threads are problematic, but they work great for us
Aaron Harper3/18/2026
Worker threads solve real problems, but they come with constraints that Go, Rust, and Python developers would never expect. Here's what we learned moving Inngest Connect's internals off the main thread.
There are too many JavaScript schema libraries, so support only one
Aaron Harper6/10/2026
What Standard Schema is, and what we learned adopting it in our TypeScript SDK.
Inngest, meet your coding agent
Sterling Chin6/3/2026
Official Inngest plugins and skills for Claude Code, Codex, Cursor, and whatever agent you already use.
Eliminating latency in AI workflows: How to avoid the durability tradeoff
Lauren Craigie2/25/2026
Every durable execution system adds some latency between steps. It's the tax we pay for reliability. Here's how to eliminate it.
Have lots of SaaS integrations? You don't need lots of reliability models.
Lauren Craigie8/26/2026
How to build a multi-tenant SaaS sync architecture with one reliability contract—and provider-specific code only where providers actually differ.
How to Build a Production AI Image Generation Pipeline with fal.ai and Inngest
Lauren Craigie3/24/2026
fal.ai runs hundreds of models at scale. Inngest orchestrates the workflow around them — retries, async coordination, per-user fairness, and observability. Here's how the two work together to build a full media pipeline.
User Built: How Windmill Built a Durable Internal Ops Agent with Inngest
Lauren Craigie3/17/2026
How Windmill replaced brittle n8n flows with a durable internal ops agent—Pim—powered by Inngest Connect, context-first design, and a focused toolset.
How We Cut Redis Read Operations by 67% with a Stateful Caching Proxy
Riadh Daghmoura3/10/2026
We reduced pressure on our sharded Redis cluster by introducing a gRPC proxy that caches immutable run state and routes consistently by run ID.
Your Agent Needs a Harness, Not a Framework
Dan Farrelly3/3/2026
Agent runtimes don't need yet another framework — they need a durable, event-driven harness that connects tools, memory, and models on production-grade infrastructure.
Sharding high-throughput Redis without downtime
Bruno Scheufler7/23/2024
Read about how we rolled our new sharded infrastructure out to production without a millisecond of downtime and how it improved Inngest's overall performance.
Your agent just learned to spend money. Now make sure it only spends it once.
Mitchell Alderson7/21/2026
Retries, crashes, and agent loops quietly turn one payment into three. Here's how to give money-moving tool calls exactly-once execution.
Online vs Offline AI Evals: When to Use Each
Mitchell Alderson7/14/2026
How offline and online evals work, what they cost to run, and when to use each for AI agents in production.
The Principles of Durable Execution Explained
Dan Farrelly12/10/2024
Learn what Durable Execution is, how it works, and why it's beneficial to your system.
step.ai: the quickest way to build reliable AI applications on Serverless while saving on compute
Charly Poly12/10/2024
Combining step.run() and step.ai.infer() is the best toolset to build reliable AI applications on Serverless while saving on compute.
Evals in Inngest: A Practical Guide to Measuring and Improving Your Agent
Lauren Craigie8/18/2026
Learn how to measure and improve AI agents in Inngest with evals—one metric at a time, deferred scoring on real outcomes, and experiments on live traffic.
After the Agent Signs In
Sterling Chin4/21/2026
Orchestration has been the undefined pillar of Agent Experience. Stripe Projects just made it core infrastructure.
You can't cancel a JavaScript promise (except sometimes you can)
Aaron Harper4/7/2026
A promise that never resolves is a surprisingly clean way to interrupt an async function.
Building Fault-Tolerant Event-Driven Systems
Dan Farrelly11/10/2022
Build fault-tolerant event-driven systems with idempotency, exactly-once processing, and event replay—durable recovery without a dead letter queue.
October 2024 queue retrospective
Darwin Wu11/7/2024
Summary of the queue related issues in October 2024
Event-driven infrastructure inventory with Inngest and NetBox
Darwin Wu5/28/2026
As we scale our datacenter footprint, we consolidated Ansible, libvirt, and NetBox inventory sync into a single Go app—using Inngest events instead of scattered coordination logic.
The Agent Loop Architecture
Dan Farrelly6/18/2026
Everyone's asking what a loop is. The question nobody's asking is what runs the loop. Durable orchestration is the execution layer underneath — and it's the foundation of the agent loop architecture.
Root Cause Analysis: July 2026 Service Incidents
Bruno Scheufler, Muzammil A., Dan Lambright7/23/2026
A combined root cause analysis of the incidents in July 2026 that affected function execution, run scheduling, checkpointing, execution metrics, and event processing.
How we built Insights AI with Inngest
Andy Lawrence1/15/2026
How we shipped Insights AI, what we learned about building agentic features, and why dogfooding your own infrastructure actually works.
Durable Execution: The Key to Harnessing AI Agents in Production
Charly Poly2/19/2026
AI Agents introduce multiple points of failure that traditional retry logic cannot handle. Durable execution provides the automatic state persistence, retries, and workflow resumption that make agents production-ready.
Inngest Python SDK: Durable Background Jobs for FastAPI, Flask, and Django
Lauren Craigie8/20/2026
Background jobs in Python have always been more painful than they should be. Celery configs, Redis brokers, worker crashes with no retries, scattered logs. The whole affair is a mess. Inngest changes this with a developer-first SDK that makes durable, event-driven functions feel like writing ordinary Python.
How to make your lead enrichment pipeline durable
Lauren Craigie4/23/2026
Learn how to build a scalable, multi-step lead enrichment and qualification pipeline using Inngest's durable execution and concurrency controls. Handles tens of thousands of leads per day across multiple enrichment providers, LLM scoring, and CRM writes—without queue sprawl or provisioning overhead.
I built a self-improving agent. It taught itself to cheat.
Mitchell Alderson (guest post)4/16/2026
I built a self-improving agent on Inngest, then learned the hard part wasn't retraining prompts, but stopping the system from gaming its own evaluation.
Inngest + Stripe Projects: Ship Durable Apps Without Leaving the Terminal
Lauren Craigie4/16/2026
Inngest is an official launch partner for Stripe Projects—a new agent-first protocol for standing up production stacks without hopping between dashboards, digging around docs, or copying keys.
Why we built a support bot that investigates tickets before drafting a reply
Jakob Evangelista4/12/2026
Support questions need evidence, not guesses. We built a bot that reads the live thread, searches the docs, finds similar historical tickets, and only then drafts a response.
How to Fix Next.js AI Route Failures (Without Restarting from Zero)
Lauren Craigie3/9/2026
Add step-level durability to your Next.js AI routes so failures don't restart from zero—each step is independently retryable and memoized.
Node.js worker threads in production
Aaron Harper6/22/2026
Spawning a worker is easy. Making it reliable means designing a protocol, packaging the worker file, proxying callbacks, handling crashes, and shutting down cleanly.
Adding a second middleware broke our typescript types
Linell Bonnette7/13/2026
How stacking middleware quietly collapsed our TypeScript inference—and what it took to fix it.
How we built a fair multi-tenant queuing system
Tony Holdstock-Brown1/22/2024
Building the Inngest queue - Part I
The Constraint API: Scaling flow control beyond millions of RPS
Bruno Scheufler2/23/2026
How we extracted constraint enforcement into a dedicated service to unlock lower latency, greater scalability, and flow control for Durable Endpoints.
Giving Inngest's Queue a Bigger Brain (and a Backup Generator): Our Migration to FoundationDB, Part 1
Bruno Scheufler, Lakshmi Kasinathan, Dan Lambright8/24/2026
Why Valkey became a ceiling for Inngest's queue—and how we chose FoundationDB as the durable, horizontally scalable replacement.
Security vulnerability in v3 TypeScript SDK
Dan Farrelly4/27/2026
CVE-2026-42047
October 2025 incident report
Darwin Wu, Dan Farrelly10/24/2025
Summary of the incident that caused function execution to fail on October 24, 2025
Explicit APIs vs Magic Directives
Tony Holdstock-Brown10/24/2025
Comparing explicit APIs vs magic directives for workflows, queues, and durable execution. Or, directives as an antipattern.
5 Lessons Learned From Taking Next.js App Router to Production
Igor Gassmann5/5/2023
What did we learn from building and shipping our new app with the Next.js 13 App Router?
How I Built an MTG Deck Analyzer with TanStack Start and Inngest
Linell Bonnette5/1/2026
I was looking for a side project to test some real concurrency. A Commander deck analyzer turned out to be the perfect excuse. Here's how I used Inngest's durable functions and Realtime to fan out parallel steps and stream results live to the UI.
How we used Inngest Queues to build Inngest's native Cron Scheduler
Lakshmi Kasinathan3/20/2026
How we improved reliability of our cron scheduler by rebuilding it on top of our own durable queue primitives.
Typescript For Apps Vs Typescript For SDKs
Inngest3/13/2026
I thought I was good at TypeScript. Refactoring the Inngest SDK proved I was okay at best—and that changed how I think about types forever.
Reducing local dev time by 83%: Why we migrated off Next.js
Jacob Heric1/30/2026
We care a lot about developer experience. But it's hard to build beautiful experiences for customers, while grinding through 10-12 second page load times. Here's how—and why—our team migrated from Next.js to Tanstack Start.
OpenTelemetry in Node.js: Tracing Express APIs
Charly Poly12/12/2025
Set up OpenTelemetry in Node.js to trace Express APIs and background jobs. Configure @opentelemetry/sdk-node and export traces to any OTLP collector.
Incident report for August 16, 2024 - Function execution outage
Dan Farrelly8/16/2024
A full report on the incident that caused function execution to fail on August 16, 2024 UTC.
Incident report for April 15, 2026 - Function scheduling and execution delays
Dan Farrelly, Bruno Scheufler4/17/2026
A full report on the incident that caused significant delays in function scheduling and execution for all customers.
How to Build AI Agents That Don't Fail Silently
Dan Farrelly8/10/2026
Use Inngest's step primitives to build resilient, observable AI agents without a heavyweight framework.
Why Analogue Never Drops an Order, Even During Flash Sales
Lauren Craigie6/25/2026
Analogue uses Inngest to power order fulfillment, multi-warehouse shipping, repairs, and analytics—keeping every async workflow reliable through flash sales.
How Outtake uses Inngest to ensure the reliability of millions of threat scans every minute, without extra infrastructure
Lauren Craigie4/28/2026
Outtake chose Inngest to abstract away the complexity of reliability infrastructure, so they can focus on advancing their agents, not worrying about how they break.
What to expect when you're expecting... to scale asynchronous workflows.
Lauren Craigie4/8/2026
Everyone needs retries. Not everyone needs priority queuing—yet. Here’s what 50,000 users taught me about when teams need to solve which problems, and why.