AwaitIO vs Airplane: the full comparison
Last updated October 25, 2026
What was Airplane?
Airplane was a developer platform for internal tools. It launched in 2021.
You took something you already had: a Python or JavaScript script, a SQL query or a call to a REST endpoint. Airplane turned it into a tool the team could run from the browser.
Each tool got a form for its parameters, a log of its runs, permissions and audit logs.
Over time Airplane added more products. Runbooks chained tasks into workflows. Views let developers write the UI of a tool in React. Autopilot was an AI assistant that wrote the code for you.
What happened to Airplane?
Airtable announced that it had acquired Airplane on 3 January 2024.
Sign-ups closed right away. The product shut down on 1 March 2024.
Customers had two months to move every tool somewhere else. There was no way to export the code.
Teams lost the tools their support and operations people used every day. Many had to rebuild them in a hurry.
The lesson for many of them: a tool that lives on someone else’s platform can disappear with it.
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 platform to sign up for and nothing hosted behind it.
AwaitIO 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
Both tools start from code a developer writes. Airplane put that code on its own platform. AwaitIO keeps it in your app.
Who owns the tools
An Airplane tool lived on Airplane’s platform. When the platform closed, the tools closed with it.
An AwaitIO action is a file in your repo, run by your own server. It keeps working as long as your app does.
No acquisition, price change or shutdown on our side can switch it off.
A script or a function that asks
Airplane started from a script you already had and put a form in front of it.
An AwaitIO action asks whenever the code needs it. It can look up an order, show it, ask for a refund amount and confirm before it charges back.
Every question is one await line. Branches, loops and error handling are plain TypeScript.
Your data and your services
An Airplane task ran on its own, apart from your app’s process.
An AwaitIO handler runs in your own process. It imports your Prisma client, your services and your utilities and calls them directly. Environment variables work as they are.
Extending the UI
In Airplane a task got a generated form. For more, you wrote a View in React against Airplane’s components, on Airplane’s platform.
In AwaitIO the whole UI stays in code, in your repo. 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.
Progress on long tasks
An action that loops over hundreds of records shows its progress with ctx.loading.
ctx.loading.start() sets a label and the number of items. ctx.loading.completeOne() moves the bar after each one.
The person sees how far it got. There is no frontend code behind it.
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.
Hosting
Airplane was a hosted platform. Its UI, its run history and its settings lived there.
AwaitIO always runs inside your own Node app, on your own servers. There is no hosted version.
Price model
Airplane no longer sells anything.
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 Airplane was stronger
Airplane took scripts in several languages, plain SQL queries and REST calls. AwaitIO actions are TypeScript only.
Airplane had Runbooks for workflows across many tasks. AwaitIO has no workflow engine.
Airplane had permissions per tool and audit logs built in. In AwaitIO, everyone who can log in can run every action.
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 Airplane this was a task with the order ID and the amount as its parameters. Showing the order before the refund took more: a second task or a View.
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
Airplane is gone, so the real choice is where its tools go next.
Choose AwaitIO if your backend is TypeScript and a developer writes the tools. They end up in your repo, reviewed and typed like the rest of the app, running in your own process.
Look elsewhere if you need scripts in many languages or long multi-step workflows on a schedule. A workflow platform fits that better.
Moving from Airplane to AwaitIO
Every Airplane task becomes one AwaitIO action. Start with the one your team runs most.
The parameters of the task become await io.input calls at the top of the action. A text parameter is io.input.text(), a number is io.input.number() and a date is io.input.date(). io.group puts several of them on one screen.
A JavaScript task moves almost as it is. Paste its body into the handler and replace the Airplane parameters with the values from io.
A SQL task becomes a call to your own database client. Show the result with io.display.table(), or let a person pick rows with io.select.table().
A REST task becomes a call to your own service, or a fetch to the same endpoint.
A View becomes a page or an action that shows tables, metadata and links. A component you wrote for a View becomes one React file registered next to the built-in ones.
A Python task has to be rewritten in TypeScript, or called from the action as it is.
Register the actions, open the AwaitIO UI from your own server and send the link to the team. Move the next task when the first one works.
Side by side
Write an async TypeScript function. Every await io.input call asks a person and waits for the answer.
Turn a script, a SQL query or a REST endpoint into a tool. Views added React UI in code.
Inside your own Node app, on your own servers.
Airplane’s hosted platform, now shut down.
In your repo, with code review, types and git history.
In Airplane. The shutdown came with no way to export it.
Comes from the code. Your own Node process serves it.
Generated for each script, or written in React with Views.
No. The source code is public. The terms are on the pricing page.
No.
FAQ
Is AwaitIO an Airplane alternative?
Yes, for teams where developers write the tools in TypeScript. Each Airplane task becomes an async function in your own repo, served by your own app.
Is Airplane still available?
No. Airtable acquired Airplane in January 2024, and the product shut down on 1 March 2024.
Can I import my Airplane tasks into AwaitIO?
There is no automatic import. A JavaScript task moves almost as it is: its parameters become await io.input calls and its body goes into the handler.
Can AwaitIO shut down my tools like Airplane did?
No. AwaitIO runs inside your own app, on your own servers. Nothing can be switched off from outside.
Can I self-host AwaitIO?
AwaitIO always runs inside your own Node app, on your own servers. There is no hosted version to move away from.
Does AwaitIO have workflows like Airplane Runbooks?
No. One action can ask, wait and run several steps in a row, but there is no workflow engine or scheduler.
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.