On June 23, 2022 I added an action called "verify user email" to a client's back office. It was my first one on Interval, and it changed how I've built back offices for my clients ever since.

On October 16 this year, on my way home from the office, I started writing my own version of it. A week later every back office I run, Edicek's included, ran on it in production.

TL;DRInterval let me write back offices as plain functions that wait for a person, and when it went self-hosted, running two servers kept me from ever changing it. On October 16 I tried my own version in one process, moved my first client to it in five days and Edicek two days later, and today I'm launching it as AwaitIO.

A function that waits for a person

Every product I've built ends the same way. It needs a back office. Somebody has to refund an order, extend a trial, fix an account. For years I did it one of two ways. Either a separate frontend and backend, with everything around it that nobody wants to build: the login, picking the components, putting the layout together. Or internal scripts that only ran from a terminal, so I ran them for everyone else.

Interval turned that around. You wrote an action like any API handler, except it could stop and wait for a human. It looked something like this:

const interval = new Interval({
  apiKey: process.env.INTERVAL_KEY,
  routes: {
    verify_user_email: async () => {
      const email = await io.input.email("User email");
      const user = await db.user.findUniqueOrThrow({ where: { email } });

      await db.user.update({
        where: { id: user.id },
        data: { emailVerified: true },
      });

      return { verified: user.email };
    },
  },
});

interval.listen();

await io.input.email(), and a form showed up in the browser. Someone typed the address, and the function went on. No frontend, no drag-and-drop.

For me it was the kind of change Claude Code is for programming today. I didn't just recommend it. I made sure it got integrated and used on every project I had a hand in, and my clients paid for it.

Two servers and a database

In November 2023 Meter acquired Interval, and by December 31 the hosted version was gone. To keep my back offices running, I had to host Interval's server myself.

I was grateful they opened it up. But every back office now meant two servers: my code with the SDK, and Interval's server with its own database and user management, all the things a SaaS needs and I didn't. It worked. And I never changed a thing. Every idea I had, a component of my own, a different layout, the kind of layer I used to build on top of it before, meant forking someone else's server and keeping it up to date. So I didn't. In September 2025 I even started the Edicek back office on it, because nothing else worked the same way.

One process

By then I had a list. Four years of building back offices on Interval had shown me exactly where it held me back, and none of it was the idea. It was everything around it.

So on October 16, on my way home from the office, I sketched what I actually wanted. One Node process that serves the UI and runs the actions, no second server. No database of its own, with users listed in code. Every component and every layout replaceable with your own React file, so nothing is ever a dead end. And the same core: a function that asks a person something and awaits the answer.

That evening I had a prototype running. I called it AwaitIO.

Underneath, nothing is Interval's. AwaitIO runs inside your own Node process, keeps runs in memory instead of a database, keeps users in your code, and draws every screen with its own React components, each in a package you can replace. What's the same is the surface: how you write an action, await io.input.email() and the like, and what a person sees when they open it, a form that asks one thing and waits.

I kept that close to Interval on purpose. It was right in 2022 and it's still right. And I had whole back offices to move, one of them 86 files of actions, that could come over almost as they were.

After four years I also write actions a certain way without thinking. I didn't want to unlearn that, and I don't think anyone coming from Interval should have to.

Five days, and then the rest

On October 20 the first version went on npm. On October 21 I moved that client's back office to AwaitIO, switched production over and deleted the old one. Two days later the Edicek back office followed, in one go.

That was the easy half. The code worked in five days. Making it something other people could pick up on their own took longer.

The brand alone went through more than 50 directions in three rounds. Not mood boards, whole brand concepts. For each one I had the current awaitio.com moved into it, every subpage included, so I could see how it would really look, plus the logo, the favicon in every state and the icons, side by side. Four days after the site first went up in its old look, I threw that look away.

If you're curious where it ended up, it's all on awaitio.com/brand.

The docs took even more. 46 pages and 59 screenshots, and 43 percent of the commits in the repo touch the documentation. Every component has its own page, because a framework you can't figure out alone might as well not exist.

Free for small teams

I want anyone to be able to host AwaitIO on their own infrastructure, with nothing held back. This tool matters to me too much for that. Individuals and small teams of up to 3 users use it for free, commercial use included, because I'm convinced developers will love it once they try it.

Bigger companies don't mind paying $50 a month for a license, and I know it. So the source is public. It isn't open source, but anyone can read it. There are no license keys and no locked features. When a team grows past 3 users, it buys the license through GitHub Sponsors, and that's it.

Launch day

It's on npm, 23 packages, and today I'm launching it on Product Hunt. If you want to see it before you install anything, here's the demo.

This week I emailed Interval's founder. I didn't ask for anything. I wanted him to know his product changed how I work, and that I see AwaitIO as a way to carry what they started a little further.

If he ever tries AwaitIO and likes it half as much as I liked Interval, that's enough.