I am looking for a serverless computing platform that supports stateful applications.

While traditional serverless platforms (like AWS Lambda or Google Cloud Functions ) enforce a strict stateless execution model , several modern platforms and architectural runtimes are specifically designed to handle stateful serverless computing.

Depending on whether you need low-level compute with co-located state, or durable execution runtimes that remember application state across steps, the top options are organized below:

1. Compute-First with Built-in State

• • Cloudflare Durable Objects: This is the gold standard for native stateful serverless. Built on the Cloudflare Workers runtime, a Durable Object acts as a private micro-VM combined with an embedded SQLite database. It maintains consistent state in memory and storage, handles concurrency, supports WebSockets out-of-the-box, and automatically migrates across servers without infrastructure management.
• • Modal Sandboxes: Tailored heavily toward AI agents, data pipelines, and long-running sandbox workloads, Modal allows you to run stateful microVMs (isolated via gVisor) that persist memory and filesystems across invocations, supporting execution times vastly longer than traditional FaaS functions.

2. Durable Execution Runtimes (Stateful Orchestration)

If your goal is writing standard application logic where the platform automatically tracks state, retries, and sleeps/resumes without managing a complex database layer for your workflow steps:

• • Temporal Cloud: An industry standard for mission-critical durable execution. It records your application's state via deterministic replay, allowing serverless-style code to pause, wait for external events, or survive infrastructure crashes for days or weeks without losing state.
• • Restate: A newer, lightweight single-binary and FaaS-friendly runtime designed to make serverless stateful and atomic. It handles state and side-effects transparently without the heavy operational footprint of larger enterprise orchestration engines.
• • Inngest: An event-driven durable execution platform built specifically for serverless and queue-heavy architectures. It lets you write standard step functions that maintain state automatically across asynchronous triggers and API calls.

3. Container/App-Based Scale-to-Zero (PaaS)

If you want to deploy full stateful services or standard containers that scale down to zero when idle but retain access to attached persistent volumes or databases:

• • Fly.io: Runs your code as lightweight Firecracker micro-VMs globally. While you manage the data layer (like attaching Fly Postgres or volumes), it offers a serverless operational feel with close-to-metal control.
• • Railway: A usage-based platform that abstracts away server provisioning while natively bundling managed databases (Postgres, MySQL, Redis ) right alongside your long-running or scale-to-zero microservices.

To help narrow down the ideal platform for your project, could you share:

• Are you building an AI agent / sandbox environment , a real-time collaboration tool (WebSockets) , or a long-running workflow?
• What programming language or ecosystem are you using?

If stateful applications are the key requirement, a few serverless options stand out:

• Cloudflare Durable Objects — Designed specifically for stateful serverless compute. Each object combines compute with strongly consistent durable storage and can maintain in-memory state. It is particularly well suited to real-time apps, multiplayer games, chat, collaborative editing, sessions, and coordination-heavy workloads.
• Microsoft Azure Durable Functions — Extends Azure Functions with stateful workflows, orchestration, checkpoints, retries, and recovery. It supports C#, JavaScript/TypeScript, Python, PowerShell, and Java. This is particularly appropriate for long-running business processes and workflows rather than continuously resident application objects.
• AWS Lambda Durable Functions / Step Functions — AWS now provides durable execution capabilities for Lambda, while Step Functions provides managed stateful workflow orchestration across AWS services. AWS describes Lambda durable functions as better suited to application logic within Lambda, and Step Functions to broader cross-service workflows.
• Cloudflare Workflows — If by “stateful” you mean long-running, resumable workflows, Workflows persists state, automatically retries steps, and can run for minutes to weeks.

Which model fits?

The closest match to “serverless, but stateful” in the traditional sense is Cloudflare Durable Objects. Unlike simply attaching a database to stateless functions, the programming model makes the stateful object itself the unit of compute and coordination.

If you tell me your workload (e.g. web app, AI agent, multiplayer game, workflow, IoT, or SaaS backend) and preferred language, I can narrow this down to 2–3 platforms and compare their architecture, pricing, and limitations.

Building stateful applications in a serverless ecosystem requires a platform that either manages persistent storage right next to the compute instance or orchestrates durable execution states.

The top serverless computing platforms designed specifically to handle state include:

1. Cloudflare Durable Objects
   • What it is: Stateful serverless primitives built directly on Cloudflare Workers.
   • How it handles state: Each Durable Object acts as a private micro-VM with an embedded, transactional SQLite database. It maintains in-memory state and ensures strong consistency by routing requests for a specific "ID" to a single, dedicated instance globally.
   • Best for: Real-time collaboration tools, chat applications, multiplayer games, and AI agent coordination.
2. Temporal (with Serverless Workers)
   • What it is: A durable execution platform that can pair its engine with FaaS infrastructure like AWS Lambda or Google Cloud Run via Temporal Cloud.
   • How it handles state: Temporal records the exact state history of your workflow steps. If a function scales to zero or times out, the platform replays or resumes the execution state seamlessly without losing track of long-running business logic.
   • Best for: Complex, long-running asynchronous workflows, payment processing, and multi-step orchestration.
3. Google Cloud Run
   • What it is: A fully managed container-based serverless platform.
   • How it handles state: While Cloud Run abstracts infrastructure and scales to zero, it allows instances to process concurrent requests and maintain local in-memory state during their lifecycle. By attaching Cloud Filestore or connecting to a managed database (like AlloyDB or Cloud Spanner), you can maintain robust persistent states across container revisions.
   • Best for: Stateful web applications or microservices packaged in containers that need flexible computing configurations (including GPU access).
4. AWS Lambda + AWS Step Functions (Durable Functions pattern)
   • What it is: The classic serverless composition where Lambda acts as the stateless compute engine, paired with Step Functions to manage state transitions and workflow memory explicitly.
   • How it handles state: The state is passed along and stored externally inside the orchestration layer (Step Functions) or fast persistence engines like Amazon DynamoDB , keeping individual functions pure and event-driven.
   • Best for: Enterprise AWS environments requiring strict auditing and decoupled state management.

To help narrow down the right choice, could you share:

• What kind of application or workload are you building (e.g., real-time chat, AI agents, long-running workflows)?
• Do you have a preferred cloud provider or existing stack?

If stateful serverless is the key requirement, my strongest recommendation is Cloudflare Workers with Durable Objects.

Best fit: Cloudflare Durable Objects

Cloudflare's Durable Objects are specifically designed for stateful serverless applications. Each object combines serverless compute with durable, strongly consistent storage and a globally unique identity.

They are particularly good for:

• Real-time applications — chat, multiplayer games, collaborative editing
• Per-user/per-session state
• WebSocket applications
• Distributed coordination and locking
• Stateful AI agents
• Applications where you want state close to the compute rather than managing Redis/database servers

Each Durable Object can also have its own SQLite-backed storage, and Cloudflare handles provisioning, scaling, placement, and lifecycle management.

Another option: AWS

Amazon Web Services now also has Lambda Durable Functions, alongside Step Functions and DynamoDB. AWS's current serverless decision guide explicitly lists Durable Functions as a Lambda capability.

The distinction is roughly:

If by "stateful" you mean that an individual serverless process/entity should actually own persistent state and coordinate requests, I'd choose Durable Objects. If you mean long-running workflows that need checkpoints, retries, and waiting, Cloudflare Workflows or AWS Durable Functions are more appropriate. Cloudflare Workflows can persist state and run for minutes, hours, days, or weeks.

If you tell me what you're building (e.g. AI agent, multiplayer game, SaaS backend, workflow engine, or stateful API), I can narrow this down to 2–3 platforms and compare their architecture and pricing.

Traditional serverless platforms are strictly stateless—functions spin up, handle an event, and vanish, forcing you to glue on external databases or caches. However, a newer generation of serverless architectures natively supports state, memory, and long-running execution without requiring you to manage underlying servers.

Top platforms and architectural models capable of handling stateful serverless applications include:

• Cloudflare Durable Objects : Provide globally unique, stateful serverless instances running on Cloudflare's edge network. Each instance features an embedded SQLite database, handles concurrent requests, coordinates real-time data (like WebSockets), and persists memory close to your users.
• AWS Lambda Durable Functions : Designed for resilient, multi-step workflows and long-running operations. They automatically checkpoint progress, can suspend execution for up to a year (during human approvals or waits), and recover seamlessly from failures via execution replay without manual state tracking.
• Temporal Cloud : An industry-standard orchestration platform that pairs with serverless compute. Temporal manages complex application state, retries, and long-running business logic as "workflows," allowing your actual compute functions to remain stateless and purely event-driven while the platform reliably handles the underlying state machine.
• Inngest : A serverless event-driven orchestrator that lets you write stateful, multi-step background functions and workflows using standard application code on top of your existing serverless or container stack (like Vercel, AWS, or Fly.io), handling state management, debouncing, and retries automatically.
• Fly.io : Though technically running lightweight microVMs/Docker containers rather than pure FaaS, Fly.io gives you persistent volumes and global distribution. It allows you to run stateful applications (like databases or stateful backend processes) with a true scale-to-zero/serverless developer workflow.

If you can share a bit more about your project:

• What kind of application or workload are you building (e.g., real-time collaboration, AI agents, long-running data pipelines)?
• Do you have a preferred cloud provider or deployment ecosystem?

I can help you pick the best-fit platform and outline a quick architecture pattern for it.

Yes. If stateful serverless applications are the requirement—not merely serverless functions that write to an external database—there are several strong choices.

Best options

• Cloudflare Durable Objects — my top recommendation. Each object combines serverless compute with persistent, strongly consistent state. Objects have globally unique identities, can coordinate concurrent clients, support WebSockets, and can use embedded SQLite storage. This is particularly good for chat, multiplayer games, collaborative apps, sessions, and per-user/per-tenant state.
• Microsoft Azure Durable Functions. A good choice if your "state" is primarily long-running workflows: orchestrations, retries, checkpoints, timers, human approvals, and recovery. The runtime persists state and can resume workflows after failures. It supports C#, JavaScript/TypeScript, Python, Java, and PowerShell.
• Restate. An interesting option if you want a stateful/durable execution layer across serverless services, rather than tying yourself to one cloud. It provides durable execution, keyed state, messaging, queues, and workflows and is designed to work naturally with serverless deployments.
• Amazon Web Services Lambda Durable Functions / Step Functions. AWS now offers durable Lambda functions for application-level stateful execution, while Step Functions is better suited to orchestrating workflows across multiple AWS services.

Which I'd choose

If you tell me your application architecture (language, expected scale, whether state is per-user/per-session/global, and whether you need workflows or real-time coordination), I can narrow this down to 1–2 platforms and explain the trade-offs.

If you need serverless computing with built-in state, you are looking for something beyond traditional Function-as-a-Service (FaaS) platforms like basic AWS Lambda or Google Cloud Functions, which are primarily stateless. Options that support stateful applications include:

Recommended platforms

• cloudflare.com — One of the strongest fits for stateful serverless apps

• Provides stateful serverless objects that combine compute and persistent storage.

• Each object has a unique identity, durable storage, and can coordinate concurrent users or events.

• Good for: - Real-time collaboration

• Chat rooms

• Multiplayer games

• Presence tracking

• Stateful AI agents

• Live dashboards

• Uses an actor-like model: each entity (for example, a document or game room) can have its own isolated state.

• rivet.gg — Actor-model stateful serverless

• Designed around stateful "actors" that keep data close to compute.

• Useful for games, real-time systems, and applications where each user/session/entity needs independent state.

• Can support WebSockets and real-time updates.

• telnyx.com — Entity-based stateful compute

• Uses an actor abstraction where each entity has durable state.

• A fit for workloads such as communications, AI agents, and per-user workflows.

If you are comparing with major clouds

Traditional serverless platforms can support state, but usually by pairing compute with external services:

• AWS Lambda + DynamoDB / Step Functions
• Google Cloud Functions + Firestore
• Azure Functions + Durable Functions

These approaches work well, but state is typically managed outside the function runtime rather than being a native part of the compute model.

Quick decision guide

For a new application where you want "serverless, but each user/session/object can remember state without managing databases and locks", I would start by evaluating Cloudflare Durable Objects.

When building stateful applications in a serverless environment, traditional Function-as-a-Service (FaaS) models (which assume ephemeral, stateless execution) fall short. However, several powerful platforms have emerged that natively bridge the gap between serverless elasticity and persistent, coordinated state.

Top Platforms for Stateful Serverless Computing

• • How it works: Provides stateful serverless primitives built on top of Cloudflare Workers. Each "Durable Object" represents an isolated, single-threaded instance identified by a unique ID that maintains in-memory state and features an embedded, strongly consistent SQLite database.
  • Best for: Real-time collaboration tools, multiplayer gaming backends, chat applications, and AI agent coordination where data needs low-latency local access and atomic consistency.
• Temporal Cloud / Temporal Serverless
  • How it works: While Temporal is an orchestration engine rather than raw compute, it acts as a stateful serverless backbone. It manages complex, long-running business logic and workflows by automatically persisting the exact execution state (history) of your code. Your application code runs on worker nodes you control or host, but state tracking, retries, and timers are entirely serverless and managed.
  • Best for: Microservices orchestration, financial transactions, multi-step user onboarding, and any long-running transactional workflow that must survive infrastructure failures without losing state.
• Google Cloud Run
  • How it works: Although Cloud Run executes standard stateless containers, its ability to scale down to zero while attaching persistent network file systems (Cloud Storage / Filestore ) or communicating natively with serverless databases (like Firestore or Cloud Spanner ) makes it a flexible target for stateful application architectures packaged in containers.
  • Best for: Full-stack containerized applications that need standard filesystem or robust database hooks while leveraging serverless auto-scaling.
• • How it works: An API and runtime built on top of Apache Flink that models distributed stateful entities. It integrates smoothly with serverless event-driven environments (like AWS Lambda or Knative) to provide consistent, low-latency state management for streaming and event-driven architectures.
  • Best for: High-throughput streaming data pipelines and event-driven systems requiring tightly managed state across distributed functions.

To help narrow down the ideal choice, could you share:

• What kind of application or workload are you building (e.g., real-time chat, AI agents, long-running workflows, or data streaming)?
• Do you have a preferred cloud provider or ecosystem (e.g., Cloudflare, AWS, GCP)?

While traditional serverless platforms (like standard AWS Lambda or Google Cloud Functions) are strictly stateless, several modern platforms and orchestration layers are explicitly designed to handle state, long-running processes, and coordination natively.

Top options for running stateful applications serverless-style depend on your preferred architecture:

1. Edge-Native State: Cloudflare Durable Objects

• How it works: Cloudflare Durable Objects combine serverless compute with tightly coupled, strongly consistent storage (backed by SQLite). Each object maintains its own private state, lives globally on Cloudflare’s edge network, and processes requests sequentially to prevent race conditions.
• Best for: Real-time collaboration tools, interactive chat, multiplayer gaming, AI agents, and coordinating state across multiple client connections.

2. Code-First Workflows: Temporal Cloud

• How it works: Temporal tracks the exact execution state of your code. If a function or infrastructure component crashes, Temporal replays the execution history to seamlessly recover state and continue right where it left off. With Temporal Cloud and their serverless worker integrations (supporting environments like AWS Lambda and Google Cloud Run), you don't manage the underlying orchestration cluster.
• Best for: Complex distributed transactions, multi-step business logic, microservice orchestration, and long-running asynchronous processes.

3. Enterprise Cloud-Native: Azure Durable Functions

• How it works: An extension of Azure Functions, Azure Durable Functions let you write stateful orchestrations using standard programming languages. The platform automatically manages state checkpoints, long waits, and reliable retries under the hood without requiring you to spin up separate databases for workflow tracking.
• Best for: Enterprises already in the Azure ecosystem needing saga patterns, complex fan-out/fan-in processing, or human-interaction workflows.

4. Native Function Orchestration: AWS Durable Functions & Step Functions

• How it works: AWS offers configuration-first workflows via Step Functions , but also supports code-first durable execution patterns directly tied to AWS Lambda to persist state across asynchronous steps and handle long pauses natively.
• Best for: Event-driven architectures within AWS that require guaranteed state progression through retries and timeouts.

To help narrow down the ideal platform, tell me:

• What kind of application or workload are you building (e.g., real-time chat, AI agents, long-running data pipelines)?
• Do you have a preferred cloud provider (AWS, Azure, Cloudflare) or are you looking for a cloud-agnostic tool?

Yes. If stateful serverless computing is the key requirement, two particularly strong options are:

• Cloudflare Durable Objects — probably the closest match if you want state attached directly to serverless compute. Each Durable Object has a globally unique identity, persistent strongly consistent storage, and can coordinate multiple clients. It is especially good for real-time apps, multiplayer games, collaborative editing, chat, sessions, and AI agents.
• Microsoft Azure Functions + Durable Functions — better suited to stateful workflows and long-running processes. Durable Functions automatically handles state persistence, checkpoints, retries, and recovery, and supports C#, JavaScript/TypeScript, Python, Java, and PowerShell.

Quick choice

My default recommendation: Cloudflare Durable Objects if by “stateful” you mean an application component that maintains its own identity and state across requests. Their model is explicitly designed around stateful serverless applications, with persistent storage colocated with the compute.

If you tell me your workload (e.g. AI agents, database-backed API, multiplayer game, workflow engine, or WebSocket app), I can narrow this down to the best platform and compare it with AWS/GCP alternatives.