Interweave Documentation

Interweave is a tool to generate permissioned, authenticated, and hosted user-interfaces for your API.

Here is why Interweave is different from other tools, and why you might like it:

  • The configuration lives with your code, so when your data model updates hit version control, your Interweave interface will stay up to date.
  • Permissions and fine-grain access controls work out of the box and are easily configurable.
  • Everything you do is composable and reusable.
  • Speed is our first priority— engineering time is precious and should be treated as such.
  • Drag-and-drops are slow and clunky; you don't ever have to use one to configure anything.

A Frontend That Lives With Your Backend

Interweave is a platform to create integrated frontends— your configuration lives with your code, but is hosted somewhere else for you. Once written, the object can be committed to version control. Whenever your data shape changes, you can update your configuration object. Your team can even set up a continuous integration to always keep your interfaces up-to-date. A configuration looks something like this:

  "key": "titles",
  "fields": {
   "title": {
      "schema": {
        "type": "string"
  "requests": {
    "get": {
      "uri": "https://dumbjson.com/titles"
    "create": {
      "uri": "https://dumbjson.com/titles",
      "method": "POST"

This object would produce an interface with a form for creating new titles, as well as a table to view titles already created.

The creation forms require no additional configuration: interfaces come with built-in support for authentication and permissions management, accessible and speedy user experience, mobile responsiveness, client-side and server-side validation, error handling, and more. If more customization is desired, Interweave offers many options in the configuration to adjust the experience.

Now, engineering time does not have to be dedicated to maintaining no-code interfaces or writing these basic interfaces from scratch. The interfaces are tightly coupled to the rest of your engineering efforts and workflow; pull requests and open-source contributions to name a few.

Get going fast. Stay moving fast.

More Features

  • 👀 Open-source (opens in a new tab)
  • 🔒 Full TypeScript support
  • 🧑‍🤝‍🧑 Permissions and access control
  • ♻️ Forms just work, always in sync with your API
  • 🔥 Blazing fast performance
  • 🔄 Version controlled
  • 🤝 Lives where you define your database schema
  • 🚀 No custom code, no logic, all static
  • 👁️ Easily generate from OpenAPI and any existing systems
  • 🌏 Compatible with any language
  • 🏗️ Configurable with your build process

How does it work?

Since an Interweave configuration is entirely static, Interweave supports any language that can write JSON and make requests.

This method of describing your interface in a static way is our implementation of an Abstract Interaction Object (AIO). This structure is static in the sense that the output cannot contain custom logic or functions. However, that does not mean that it has to be constructed in a static way. The underlying data format is JSON, so any language can compose the objects however they see fit, as long as JSON is sent to Interweave.

Once the configuration is sent to Interweave, your configuration will be validated and built. This only takes a few moments. Once done, the interface will be ready for use.

The static nature of Interweave allows for the rapid development of business-critical interfaces through pre-defined component definitions and data-fetching patterns. This modular, yet static approach enables organizations to assemble fully functional interfaces for their teams quickly and efficiently without writing any custom logic.

You can see more details on the Getting Started page, but getting going is three steps:

  1. Create a project in Interweave
  2. Define your structure
  3. Send to Interweave


Interweave was created by Mike Carbone (opens in a new tab) in March 2023. The project is young, and actively welcoming contributors.