What features does Instant include, and how do you get started?

Updated

Instant is a real-time backend for AI-coded apps that bundles auth, permissions, storage, presence, and streams into one service, and it is designed to be operated entirely from the CLI. You get started by creating an account, spinning up a database, pushing a schema and permission rules with instant-cli, then initializing the client library in your frontend and reading/writing data directly. One important condition: Instant is sunsetting, and services will continue until August 31st, 2027, so it is best suited for projects that can ship and wind down within that window.

What Instant includes

Instant describes itself as "a database in your frontend" with a relational core, and the page lists these included capabilities:

  • Auth — authentication for your app's users.
  • Permissions — declarative rules that control who can view, create, update, and delete data.
  • Storage — file storage alongside your data.
  • Presence — knowing who is online or active.
  • Streams — streaming data to clients.
  • Real-time queries — reads that update instantly, support multiplayer, and work offline.

The pitch is that these are "batteries included," so you don't assemble separate services for each concern.

How the data model and permissions work

Instant uses a declarative schema and declarative rules, both defined in code. From the page's examples:

A schema defines entities and their fields:

import { i } from "@instantdb/core"

const schema = i.schema({
  entities: {
    messages: i.entity({
      text: i.string(),
      createdAt: i.date(),
    }),
  },
})

export default schema

Permission rules bind expressions to auth state and then allow or deny actions:

const rules = {
  messages: {
    bind: { "isOwner": "auth.id == data.creator" },
    allow: {
      view: "true",     // Anyone can view
      create: "isOwner", // Only owner
      update: "isOwner", // Only owner
      "delete": "isOwner", // Only owner
    },
  },
}

export default rules

The bind block names a reusable condition (isOwner), and allow maps each operation to a rule. This is the mechanism behind "permissions" being a first-class feature rather than something you bolt on.

Getting started from the terminal

Instant is built to be operated from the CLI, so an agent or a human can do everything without a dashboard. The page shows this push command:

npx instant-cli push schema chat.tsx schema.ts perms.ts

The inputs are your schema file and permissions file; the action is pushing them to your Instant app; the expected result is that your database structure and rules are live. The page's stated flow is: create an account, spin up a database, push schema, and build — all from the terminal, with "undo built in" when things go wrong.

Using it in a React frontend

Once the backend is set up, you initialize the client with your app ID and use queries and transactions. The page's chat example:

import { init, id } from "@instantdb/react"

const db = init({ appId: "your-app-id" })

function Chat() {
  // 1. Read
  const { data } = db.useQuery({ messages: {} })

  // 2. Write
  const addMessage = (msg) => {
    db.transact(db.tx.messages[id()].update(msg))
  }

  // 3. Render!
  return <UI data={data} onAdd={addMessage} />
}

export default Chat

The pattern is three steps: read with useQuery, write with transact, render. Because queries are real-time, the UI updates instantly and supports multiplayer and offline use without extra wiring.

Who it's for, and the sunset caveat

Instant is aimed at AI-coded apps and startups — the page notes backing from Y Combinator and SV Angel, and endorsements from figures like Greg Brockman, Jeff Dean, Paul Graham, Amjad Masad, Karri Saarinen, and Zach Sims, plus 50+ technical founders. It's positioned as "easy for humans, perfect for LLMs," which is why the CLI-first, no-dashboard design matters: your agent can do everything a human can.

The trade-off to weigh before starting: Instant is sunsetting, with services continuing until August 31st, 2027. If you're building something with a lifespan inside that window, the bundled features and terminal workflow are a strong fit. If you need a backend with a longer guaranteed horizon, that date is the deciding factor.