AwaitIO vs Interval: the full comparison
Last updated October 25, 2026
What is Interval?
Interval was a tool for building internal tools with backend code only. It launched in 2022 and reached version 1.0 in April 2023.
You wrote an action as an async function in Node.js or Python. Each await io.input call showed a form in the browser. The function waited until a person answered, then went on with the value.
Its pitch was internal tools for engineers who love writing code but hate building UIs. No drag-and-drop, no API endpoints and no frontend code.
Two pieces worked together. The SDK ran inside your code, on your own servers. The browser UI came from Interval’s hosted service, which also handled login, teams, permissions and audit logs.
Interval also offered scheduled runs, environments, notifications by Slack and email, and links between actions.
What happened to Interval?
Meter, a network hardware company, acquired Interval in November 2023. Meter uses it internally.
interval.com now redirects to meter.com. The hosted service is gone.
Teams that used hosted Interval kept their code, but lost the UI it talked to.
The code is still public under the MIT license, with docs at intervalkit.com. Running Interval today means hosting the Interval server yourself, next to your app.
What is AwaitIO?
AwaitIO is a framework for internal tools written as code. An action is an async TypeScript function in your own repo.
Every await io.input call asks a person for something and waits for the answer. The browser shows the form, the person fills it in, and your function goes on with the value.
The same Node process that runs your app serves the UI. There is no hosted service behind it and no second server to run.
AwaitIO was built by a developer who used Interval for several years. It keeps the same await model and drops the hosted part.
It ships more than 20 components: inputs, selects, displays, a confirm and a layout. Anything missing is one React file you register next to them.
Key differences
AwaitIO and Interval share the core idea: the code asks, a person answers in the browser. The differences are in where the UI comes from and how far you can change it.
The same await model
An action reads top to bottom in both tools. await io.input.email() asks for an email. await io.select.table() lets a person pick rows. await io.confirm() asks before something irreversible.
Most method names are the same. io.group still puts several fields on one screen. ctx.loading still shows progress while a long loop runs.
Branches, loops and error handling stay plain code. If you wrote Interval actions, you already know how to write AwaitIO actions.
Where the UI comes from
With Interval, your code connected to Interval’s server, and that server showed the UI. You either used the hosted one or ran the open-source server yourself.
With AwaitIO, there is one process. app.listen() starts your actions and the UI together, on a port of your app.
Login is built in too. The people who can log in are a list in your code.
Built-in components
AwaitIO ships eight inputs: text, email, URL, textarea, number, boolean, date, and date and time.
It ships three selects: single, multiple and a table to pick rows from.
It ships eight displays: heading, HTML, image, link, Markdown, metadata, object and table. A confirm and a layout complete the set.
Each one is its own package. You install only the ones you use.
When the vendor changes course
Interval’s hosted service ended with the acquisition. The actions were still in your repo, but nobody could run them in the browser any more.
AwaitIO has no hosted part. It is a package in your app, so no acquisition, price change or shutdown can switch your tools off.
Extending the UI
Interval gave you the components it shipped. The look and the page around them came from its UI.
In AwaitIO the whole UI stays in code. A component of your own is one React file with its props and the value it returns. You register it next to the built-in ones and await it like any io method.
The look comes from a theme package you can restyle. The page around the components comes from a layout component you can replace with your own. You never leave your editor.
Languages
Interval had SDKs for Node.js and Python.
AwaitIO is TypeScript on Node only. In return, every answer is typed and checked on the server, and the compiler sees every action next to the rest of your app.
Price model
Interval’s hosted plans are gone. The open-source server is free, and you host and maintain it yourself.
AwaitIO is free for small teams, commercial use included. Above that it is one flat monthly price per organization, not per seat. The details are on the pricing page.
Where Interval is stronger
Interval has a Python SDK. AwaitIO is TypeScript only.
Interval had scheduled runs with cron, teams and permissions, and notifications by Slack and email. AwaitIO does not have these built in.
The Interval server is MIT licensed. AwaitIO’s source is public, and its terms are on the pricing page.
An example: refunding an order
Support needs to refund an order. Someone types the order ID, checks the order, enters an amount and confirms.
In Interval this was one action too, and it read almost the same. The difference was where the form came from: Interval’s service drew it.
In AwaitIO it is one action. await io.input.text() asks for the order ID. The action loads the order with your own database client and shows it with io.display.metadata().
Then await io.input.number() asks for the amount and await io.confirm() asks before the money moves. The action calls your payment service and returns a message for the person.
The whole tool is one function of about twenty lines, in one file, in your repo.
Who should choose which
Keep Interval if you already run its open-source server yourself, it does what you need and you are fine maintaining it.
Keep Interval as well if your actions are written in Python.
Choose AwaitIO if you used hosted Interval and your actions need a new home. Or if you want the same model in TypeScript, served by the app you already run, with a UI you can extend.
Moving from Interval to AwaitIO
Most actions move almost line by line, because the io calls are so close.
An Interval action was an async (io, ctx) function in the actions of new Interval({ … }). In AwaitIO each action is one file in the actions folder, written with app.defineAction(). Its handler takes one object: async ({ io, ctx }).
io.input.text, io.input.email, io.input.number, io.input.boolean, io.input.date, io.input.datetime and io.input.url keep their names. Dates come back as luxon DateTime values.
io.select.single, io.select.multiple and io.select.table keep their names. So do io.display.heading, io.display.markdown, io.display.metadata, io.display.object, io.display.link, io.display.image, io.display.table and io.confirm.
.optional() still makes a field optional. io.group takes an object of io calls and returns the values under the same keys.
ctx.loading.start(), ctx.loading.update() and ctx.loading.completeOne() work as before. ctx.user and ctx.params are there too.
Each component is its own package, such as @awaitio/input-text. Register the ones you use in new AwaitIO({ … }). A call with no built-in counterpart becomes one React file of your own.
Drop the Interval API key and endpoint. Put your people into users and start the server with app.listen(). Then move the next action.
Side by side
Write an async TypeScript function. Every await io.input call asks a person and waits for the answer.
Write backend functions in Node.js or Python. await io.input asks a person.
Inside your own Node app, on your own servers.
Your code on your own infrastructure. The UI came from Interval’s hosted service, which is gone.
In your repo, with code review, types and git history.
In your repo.
Comes from the code. Your own Node process serves it.
Comes from the code, shown by Interval’s hosted UI.
No. The source code is public. The terms are on the pricing page.
Yes, the server is MIT licensed.
FAQ
Is AwaitIO an Interval alternative?
Yes. It uses the same model: an action is an async function, and every await io.input call shows a form and waits. The UI is served by your own app instead of a hosted service.
Is Interval still available?
Not as a hosted product. Meter acquired Interval in November 2023, and interval.com redirects to meter.com. The code is still public under the MIT license, with docs at intervalkit.com.
How hard is it to move Interval actions to AwaitIO?
Most actions move almost line by line. The io method names are mostly the same, and ctx.loading, ctx.user and ctx.params work as before. The handler takes one object, async ({ io, ctx }).
Can I self-host AwaitIO?
AwaitIO always runs inside your own Node app, on your own servers. There is no hosted version and no second server to run.
Does AwaitIO support Python like Interval did?
No. AwaitIO is TypeScript on Node only.
Can I add my own components?
Yes. A component is one React file with its props and the value it returns. You register it next to the built-in ones and await it like any io method.
Does AwaitIO charge per seat?
No. It is free for small teams and one flat monthly price per organization above that. The pricing page has the details.