Comparison # JustScale vs Inngest & Restate Durable functions as a hosted service vs a framework primitive. JustScale, Inngest, and Restate all make multi-step, long-running work durable, but they live at different layers. Inngest is an event-driven, largely hosted platform for durable step functions, popular in serverless setups where retries and step memoization are handled for you. Restate is a durable-execution runtime (a sidecar/server) that makes handlers durable. JustScale folds durability into the application framework itself: processes are plain async code, suspend on typed signals or timers, and persist to a database you already run, with no external service or runtime. Choose Inngest or Restate when you want a dedicated, hosted (or sidecar) durable-function layer, especially in serverless or polyglot environments. Choose JustScale when you want durable workflows as a native part of a typed, DDD-oriented backend, sharing the same runtime, types, and database as the rest of your application. ## JustScale vs Inngest & Restate at a glance | Aspect | JustScale | Inngest & Restate | | - | - | - | | Deployment model | In your app; state in your database | Inngest: hosted/serverless event platform. Restate: durable runtime/sidecar | | Programming model | Plain async code compiled to durable processes | Step functions / durable handlers via SDK | | Triggering | Typed, path-based signals + HTTP/CLI/WS controllers | Events (Inngest) / durable RPC handlers (Restate) | | Infrastructure | Database you already run | A hosted service or a separate runtime to operate | | Domain integration | Shares DI, types, ID-free domain, and locks | External to your domain model | | Languages | TypeScript | Multiple, depending on platform | ## Choose JustScale when - +You want durable workflows native to a typed, domain-driven backend, not a separate service. - +You want a complete framework too — multi-transport controllers, auth, permissions, OpenAPI, and testing — alongside the durable layer. - +You prefer to keep durable state in a database you already operate. - +Signals, locks, and channels integrated with your domain are valuable to you. ## Choose Inngest & Restate when - +You run serverless and want a hosted platform to manage retries and step state (Inngest). - +You want a language-agnostic durable runtime as a sidecar/server (Restate). - +You prefer an external durable layer decoupled from your application framework. ## Switching from Inngest & Restate - →Inngest steps and Restate durable handlers become steps inside a JustScale process handler. - →Event triggers map to JustScale signals or controller routes. - →Built-in retries become explicit control flow or service-level retry policy inside the process. - →You drop the external platform/runtime; durable state moves into your database. ## Frequently asked questions ### Is JustScale hosted like Inngest? No. JustScale runs inside your application and persists durable state to your own database. There is no hosted service to sign up for. ### How does JustScale differ from Restate? Restate is a language-agnostic durable runtime you operate alongside your app. JustScale builds durability into a TypeScript framework, sharing your types, DI, and database. ## Learn more [Durable Processes](https://justscale.sh/docs/processes/overview)[Signals](https://justscale.sh/docs/processes/signals)[Channels](https://justscale.sh/docs/fundamentals/channels)[Quick Start →](https://justscale.sh/docs/overview/quick-start)