Answers from our docs and articlesesc to close
Try asking
Create an accountSign up

Coming from Gadget: what you keep, what you gain, and what you'll rewrite

Gadget shuts down on March 31, 2027. How to move a Gadget app to Inference Bureau with the import: what converts, what you gain, and what you'll finish by hand.

Key takeaways

  • Gadget is shutting down. Its apps keep running until March 31, 2027, no new apps can be started, first production deploys end with November 2026, and support ends with the year.
  • What you know from Gadget carries over: models, model and global actions with run and onSuccess, filters shaped { field: { operator: value } }, user and session models for web apps, and synced Shopify models with the names you know. A model action usually ports with two edits.
  • What Inference Bureau adds: model calls on your team's bill with no provider key, a Shopify app made for every environment, schema changes with no migrations, record history you can restore, a deploy plan on every pull request, preview environments, and a dev server on your own machine.
  • The Gadget import converts an app's files, copies its records into development and production, and moves a Shopify app's stores over without a reinstall. What it can't convert, such as the frontend (Next.js here) and HTTP routes, it lists file by file for you or your coding agent.

Gadget is shutting down. In November 2026 it told its developers that the platform stays up until March 31, 2027, and that apps on it run as normal until then. Whether you built a web app or a Shopify app on Gadget, it has to move before that day.

What Gadget's announcement means for you

These are the dates from Gadget's email to its developers:

DateWhat changes
NowNo new Gadget apps can be started. Existing apps keep running.
End of November 2026Last day for an app's first deploy to production. Apps already in production can keep deploying.
End of December 2026Gadget's support ends. After that, the team says it will keep the lights on and tend to critical issues.
March 31, 2027The platform shuts down.

Gadget says it will publish guides and tools for moving apps to other platforms in the coming weeks, and email developers when they're ready. It's also open to members of its community taking Gadget over in some form. If you're a Gadget partner, your partner manager will reach out. Anyone can reach Gadget's support at support@gadget.dev.

You don't need to move anything today, but Gadget asks you to start planning now, and we agree. For a web app or a custom Shopify app on one store, a move is a port, a data import and a switch-over. For a public Shopify app, every merchant has to install the new app before March 31, and that takes longer than the code.

Moving to Inference Bureau

If you've built on Gadget, you already know most of what it takes to build on Inference Bureau. Apps, our app platform, hosts web apps and Shopify apps with the same ideas Gadget uses. You describe data as models, write the code that changes it as actions and read records with filter objects. A web app signs its users in with user and session models, and a Shopify app works with Shopify's data as synced models. Those ideas, and much of the code you've written with them, move over with small edits.

What changes is everything around that code: how a change gets to production, what you can see and undo once it's there, where model calls are billed, and how much of the Shopify setup you do by hand. Most of this guide is about those parts.

It's for deciding where to move, and for planning the move. It covers what Inference Bureau gives you, what carries over, what you'll rewrite, what Inference Bureau doesn't do yet, the import that does most of the move, and both price lists. Most of it applies to every app. Where a part is only for web apps or only for Shopify apps, it says so.

The shutdown dates come from Gadget's email to its developers. Everything else about Gadget here comes from its public docs and pricing page, read on October 23, 2026, and cited as we go.

What you get on Inference Bureau

Shipping without surprises

  • Schema changes without migrations. Records are stored as JSON keyed by each field's storage key, so a deploy never runs DDL. A removed field's values are hidden, not deleted, and come back if the field returns with the same storage key.
  • A deploy plan before every deploy. Each deploy lists its file changes, each model change and how many production records it reaches. A pull request into a branch an environment follows gets that plan as a GitHub check, and the check fails when the change would break existing records: a removed field still holding values, a new type some values can't take, or a new required or unique rule. You find out before the merge.
  • Environments that follow a branch. An environment can deploy from a GitHub branch on every push (more here). Web apps can give each pull request a preview environment of its own, with its address on the pull request, deleted at merge (more here).
  • An email when production fails. When an action throws, a job gives up, a deploy or a Shopify release fails, or a route answers 5xx, the team gets an email that names what failed, with links to its events in Logs.

Building faster

  • The dev server on your machine. ib-apps dev can run next dev on your own computer, with the environment's variables, and point the app's development address, actions, app proxy and jobs at it through a tunnel. You keep your own debugger and editor, and there's no sandbox to wake.
  • An assistant in every app page, and an MCP server for your agent. Press ⌘K to ask the assistant to make a change while Files, Preview and Logs stay in view. Development's MCP server gives your own coding agent the same tools: read and edit files, create models, add fields and actions, grant roles, read problems and deploy. The schema tools set storage keys and keep them on a rename, so the files an agent writes are well formed.
  • An API reference that writes itself. Every environment has a page listing each model, field and action, with who may call it and code in SDK, curl, fetch and MCP. You can download it as OpenAPI 3.1.
  • Tests against in-memory records. ib-apps test runs Vitest with @inferencebureau/apps-sdk/test, which loads your schemas and actions and stubs the Admin API. See Testing.
  • Recipes. A new app can start from one of the example apps, such as product reviews with moderation, a wishlist, bundles with a Shopify Function or a Shop Mini's backend, with the recipe's Shopify scopes filled in.
  • Index hints. When a read on a large model is slow for lack of an index, Problems shows the indexes entry that would serve it.

Your data, live and recoverable

  • Live queries. Pass live to useFindMany or AutoTable, and the page updates whenever the records change, whether a Shopify sync, a job or another staff member changed them.
  • Aggregates. api.<model>.aggregate answers questions like reviews per product per month without reading every record, grouped by up to four fields or by time in a time zone.
  • Record history and restore. Every create, update and delete is kept for the plan's restore window, whatever made it. On Settings → Backups you can preview a restore of one model or all of them to a point in time, then run it. See Backups.
  • Hourly reconcile. Every synced model is checked against Shopify every hour, so a missed webhook is fixed within the hour. Customers and orders are swept daily. Gadget's docs describe a daily scheduled sync for models Shopify sends no webhooks for.

Fewer keys, less Shopify setup

  • A Shopify app per environment, made for you. For Shopify apps, setup creates the development and production Shopify apps in your Partner organization, with URLs, webhooks and the app proxy filled in. A new development environment gets its own Shopify app too. Gadget's docs say each developer creates and connects their own.
  • The store's token never reaches your code. Shopify calls go through Inference Bureau, which adds the store's offline token, so it's never in your app's code or environment.
  • Model calls on the same bill. The ai in every action's context goes through Inference Bureau's gateway. Calls are held to your team's Directives and budgets, show up in Logs and come out of the team's balance. There's no provider key to add. See Putting a model in a Shopify app without a second API bill.
  • Secrets from 1Password. An environment variable can be an op:// reference, read from your vault at every build.
  • Unlimited members on every plan. No seat caps, so the whole team, and the agency or client you build for, can be in the app.

How your Gadget knowledge maps

Most concepts have a direct counterpart. Use this table to translate as you read the Apps docs:

GadgetAppsNotes
api/models/<model>/schema.gadget.tsapi/models/<model>/schema.ib.tsBoth export schema. The type changes from gadget/model-schema/v2 to ib/model-schema/v1. Both use storageKey on fields.
Model actions in api/models/<model>/actions/The same folderEach file exports run, and optionally onSuccess, options and params.
Global actions in api/actions/The same folderTyped GlobalActionRun; record is null.
applyParams, save, deleteRecord from gadget-serverThe same names from @inferencebureau/apps-sdkapplyParams(params, record) takes the same argument order.
actionType, returnType, timeoutMSThe same optionsBoth cap an action at 15 minutes. Apps defaults to 30 seconds, or five minutes as a background job.
accessControl/permissions.gadget.tsaccessControl/permissions.ib.tsSame role names: unauthenticated, system-admin, signed-in, shopify-app-users. Filters are written inline, not in Gelly files.
settings.gadget.tssettings.ib.tsHolds webhook topics and schedules in Apps (below).
connections.shopify.currentshopify in the action's contextBound to the store the run is about. createShopifyClient(shop) elsewhere.
Shopify models (shopifyShop, shopifyProduct, …)The same model namesPicked on one settings page. Each is a schema file Apps writes and keeps filled.
api.enqueueapi.enqueueDifferent arguments and options (below).
user and session models in a web appThe same models in the web starterEmail and password sign-in, email confirmation and password reset, with currentUser() and requireUser() in web/lib/auth.ts.
Development and production environmentsThe sameUp to ten development environments per app. In a Shopify app, each gets its own Shopify app.
ggt dev, pull, push, status, deployib-apps dev, pull, push, status, deployTwo-way sync with the hosted environment, as ggt dev does.
web/ (React with Vite, or Remix)web/ (Next.js App Router)The biggest rewrite for most apps.
HTTP routes in api/routes/ (Fastify)Next.js route handlers in web/app/Same job, different framework.

Sources: Gadget's metadata files, action code, access control, environments and ggt pages; on our side, Actions, Access control and Shopify apps.

What ports nearly unchanged

Model actions

A model action keeps its shape. Here's an approve action that tags the product in Shopify once the approval has committed, written for Gadget:

// Gadget: api/models/review/actions/approve.ts
import { applyParams, save, ActionOptions } from "gadget-server";

export const run: ActionRun = async ({ params, record }) => {
  applyParams(params, record);
  record.status = "approved";
  await save(record);
};

export const onSuccess: ActionOnSuccess = async ({ record, connections }) => {
  const shopify = connections.shopify.current;
  if (!shopify) return;
  await shopify.graphql(
    `mutation ($id: ID!) { tagsAdd(id: $id, tags: ["reviewed"]) { userErrors { message } } }`,
    { id: record.productGid },
  );
};

export const options: ActionOptions = { actionType: "update" };

And the same action in Apps:

// Apps: api/models/review/actions/approve.ts
import { applyParams, save, type ActionOnSuccess, type ActionOptions, type ActionRun } from "@inferencebureau/apps-sdk";

export const run: ActionRun = async ({ params, record }) => {
  applyParams(params, record);
  record.status = "approved";
  await save(record);
};

export const onSuccess: ActionOnSuccess = async ({ record, shopify }) => {
  if (!shopify) return;
  await shopify.graphql(
    `mutation ($id: ID!) { tagsAdd(id: $id, tags: ["reviewed"]) { userErrors { message } } }`,
    { id: record.productGid },
  );
};

export const options: ActionOptions = { actionType: "update" };

Two lines changed: the import, and where the Shopify client comes from. run and onSuccess keep their roles. run's write commits when it returns, and onSuccess runs only after that, so Shopify calls, emails and model calls still belong there. Apps also runs a model's create, update or delete action when a record is written through the API, as Gadget does. Rules every write must follow still go in those files.

Reads and filters

Filters keep Gadget's shape, { field: { operator: value } }, with AND, OR and NOT lists. In Apps, a sort is "Ascending" or "Descending" per field, and reads take filter, sort, search, select, first and after:

const page = await api.review.findMany({
  filter: { status: { equals: "approved" }, rating: { greaterThanOrEqual: 4 } },
  sort: { createdAt: "Descending" },
  select: { rating: true, body: true, product: { select: { title: true } } },
  first: 25,
});
page.records; page.hasNextPage; page.endCursor;

findMany answers { records, hasNextPage, endCursor }. Code that walks the result directly needs .records added. Filters also reach through relationships ({ product: { vendor: { equals: "IB" } } }, { reviews: { some: … } }). See Reading and writing records.

Shopify models and installs

For a Shopify app, the synced models have the names you know: shopifyShop, shopifyProduct, shopifyProductVariant, shopifyOrder and more than thirty others, listed on the Shopify apps page. As in Gadget, a webhook for a synced model runs that model's action of the same name, and records carry shopifyUpdatedAt so stale deliveries are skipped. shopifyShop's install and uninstall actions run on Shopify's install and app/uninstalled events, plus reinstall when a store comes back.

What you'll rewrite

The import (below) does much of this for you: Gelly filters it can read become inline filters, triggers move into settings.ib.ts, and api.enqueue calls and internal API writes are rewritten. What it can't convert, it lists in GADGET_IMPORT.md. This section is what those changes are, and what's left when the import can't make them.

Gelly

Gadget writes access filters and computed fields in Gelly, its data access language, in their own files. Apps has no Gelly. A role's filter is the same filter object as findMany's, written inline in permissions.ib.ts:

"storefront-shoppers": {
  models: { review: { read: { filter: { status: { equals: "approved" } } }, actions: { create: true } } },
},

{ $session: "userId" } stands for the caller's value. A filter left in a file under accessControl/filters/ isn't read and grants nothing, and the refusal names it, so you'll notice. Computed fields move into the schema as { type: "computed", aggregate: { avg: "reviews.rating" } } or as an expression like "round(price * 1.2, 2)". See Models.

Transactions

In Gadget, a model action's run is a transaction, and writes through the internal API inside it join that transaction. Apps writes nothing while run runs. It collects what you save and applies it in one transaction when run returns. To write other records with the action's own, read them through api or make them with api.<model>.build(values), then save each one:

await save(api.orderLine.build({ order: record.id, sku: line.sku, quantity: line.quantity }));

api.<model>.create, update and delete write at once, outside the transaction, and stand even if run later throws. Look for internal API writes in your actions and decide which kind each one should be. A run can stage up to 500 other records.

Triggers and background jobs

Gadget declares schedules and Shopify webhook topics as triggers in an action's options. Apps lists both in settings.ib.ts, each naming the global action it queues:

export const settings: AppSettings = {
  type: "ib/settings/v1",
  platform: "shopify",
  webhooks: [{ topic: "orders/create", action: "orderCreated" }],
  schedules: [{ action: "nightlyDigest", cron: "0 3 * * *", timezone: "America/New_York" }],
};

api.enqueue takes the action by name instead of by reference, and its options differ. Gadget's queue: { name, maxConcurrency } becomes concurrencyKey and concurrency. startAt becomes runAt, or delay in milliseconds:

// Gadget
await api.enqueue(api.syncCatalog, { since }, { queue: { name: shopDomain, maxConcurrency: 1 } });
// Apps
await api.enqueue("syncCatalog", { since }, { shop: shopDomain, concurrencyKey: shopDomain });

Retries default to six on both, and priority takes high, default or low on both. See Background jobs and schedules.

The frontend and HTTP routes

Pages in Apps are a Next.js App Router app under web/. A React app built with Vite moves over component by component, but routing, layouts and data loading follow Next.js. Fastify routes in api/routes/ become route handlers such as web/app/proxy/reviews/route.ts.

The React hooks have the same names with a different call shape. They take the model's name as a string and return an object:

// Gadget
const [{ data, fetching, error }, refetch] = useFindMany(api.review);
const [, approve] = useAction(api.review.approve);
// Apps, from @inferencebureau/apps-sdk/react
const { data, fetching, error, refetch } = useFindMany("review", { first: 20 });
const approve = useAction("review", "approve"); // approve.run({ id })

AutoTable and AutoForm draw a model's records and forms, in Polaris or in plain elements. See Tables and forms.

Sign-in for a web app

A new web app starts with sign-up, sign-in, sign-out, email confirmation and password reset already working, built on user and session models and web/lib/auth.ts. Carry your user model's own fields over to it rather than porting Gadget's auth. Emails go out through your own Resend key. Passwords can't move: a password field is hashed when it's written, so a hash exported from Gadget wouldn't match. Import your users without one and send each a reset link.

What Inference Bureau doesn't do yet

Some things you may use on Gadget have no match on Inference Bureau yet:

  • Other platforms. Gadget connects to BigCommerce as well as Shopify. Apps hosts web apps and Shopify apps, so a BigCommerce app needs another home.
  • Frontend choice. Gadget supports React with Vite and Remix. Apps pages are Next.js only. We're exploring Astro as a second option, with no date yet.
  • Unlimited development environments. Gadget lists them on every plan. Apps allows ten per app.
  • More from the CLI. ggt scaffolds models, fields and actions, manages variables and environments, and streams logs. ib-apps syncs, deploys, tests, imports and exports records, runs Shopify syncs and manages domains. Variables and environments live in the dashboard. Logs are in the dashboard and in the MCP server's list_events tool.
  • A stable SDK. Apps is in beta, and its SDK is still 0.x.

Moving with the import

The Gadget import converts your app's files, then a checklist moves the rest: development's records, production's records, and a Shopify app's stores or a web app's domain. Your Gadget app keeps running the whole time, and nothing reaches its users until you switch over. Do it while Gadget's support is still answering, before the end of December, in case you need something from your Gadget app you can't get yourself.

  1. Pull the app with Gadget's CLI. In an empty folder, npx ggt pull --app=<your-app> --env=development writes your Gadget app's files. Nothing on Gadget changes.
  2. Import it. In the dashboard, New app → Import from Gadget, then choose that folder. The review shows what converts (models, actions, permissions, settings, extensions) and what's left, before anything is created. From the terminal, ib-apps import gadget <folder> writes the converted files into a folder linked to an app. A Shopify app keeps the same scopes and synced models; a web app keeps its user model's own fields on the web starter's sign-in.
  3. Finish what's listed. GADGET_IMPORT.md lists each thing left, file by file, with what to do: pages to move into Next.js, HTTP routes to move into route handlers, environment variables to set, and lines that call something Gadget had. A skill beside it teaches your coding agent the same mapping. The app's Problems list shows anything that doesn't type-check.
  4. Copy development's records. The move's checklist, in the app's Settings → General, copies your Gadget development environment's records with a Gadget API key that has the system-admin role (ib-apps import gadget --records <url> does the same). Relationships are kept, synced Shopify records come along, and running it again updates what it copied.
  5. Deploy, which creates production.
  6. Move production. For a Shopify app, the checklist connects the Shopify app your Gadget app uses, copies production's records, switches the Shopify app over so its URLs, webhooks and app proxy point here, carries every store's install over from Gadget, and copies the records once more so nothing written on Gadget in between is lost. For a web app, it copies production's records, then you point your domain here (see Custom domains), and it copies again.

Because a Shopify app keeps the Shopify app your Gadget app used, merchants don't install anything again: the stores it's installed on are served from here from the switch-over. Users of a web app sign in with the same email, but passwords can't move, since Gadget never gives password hashes out, so send each user a reset link.

Prices, as published on October 23, 2026

From Gadget's pricing page and our Plans and usage page, both read on October 23, 2026:

GadgetApps
Free planHobby, $0: 2 seats, 1 production environmentFree, $0: 1 production app, 5 production store installs
Middle planPro, $35 a month: 10 seatsPro, $35 a month: unlimited production apps and installs
Top published planPremium, $350 a month: 25 seatsScale, $299 a month
SeatsCapped per planUnlimited members on every plan
What's meteredCPU time, data and search storage, database read and write compute, edge bandwidth and platform creditsRuns, requests, storage and bandwidth, in production only

The meters don't line up, so the plan prices alone don't tell you which costs less for your app. Gadget's Pro includes 30 hours of CPU time, 3 GB of data storage and 1M platform credits. Apps Pro includes 500,000 runs, 1,000,000 requests, 5 GB-months of storage and 50 GB of bandwidth. To compare, take a month of your app's real traffic and price it on both pages. Apps also bills model calls separately, at the gateway's price, from the same team balance.

Frequently asked questions

When does Gadget shut down?

March 31, 2027. Until then existing apps keep running. New apps can't be started, an app's first production deploy has to happen by the end of November 2026, and Gadget's support ends with December 2026.

Can I import a Gadget app automatically?

Yes. Pull it with ggt, then use New app → Import from Gadget in the dashboard, or ib-apps import gadget <folder>. Models, actions, permissions and settings convert; what doesn't is listed in GADGET_IMPORT.md. The move's checklist then copies records from Gadget's development and production environments.

Do my Gadget actions run unchanged?

Most model actions need two edits: the import, which becomes @inferencebureau/apps-sdk, and the Shopify client, which becomes shopify in the context instead of connections.shopify.current. Actions that rely on writes joining the transaction, on Gelly, or on triggers in options need more.

Can my web app's users keep their passwords?

No. Apps hashes a password field when it's written, so a hash exported from Gadget wouldn't match. Import your users without passwords and send each a reset link; the web starter's password reset is already built.

Will my merchants have to reinstall?

No. The move connects the Shopify app your Gadget app uses, switches its URLs and webhooks over, and carries each store's install over from Gadget, so stores keep the app they installed.

Does Apps use Gelly?

No. Access filters use the same filter object as findMany, written inline in permissions.ib.ts, and computed fields are aggregates or expressions in the schema.

One bill for your apps, your models and your reviews.

Host apps and functions next to your model traffic. Routing picks each turn's model by your quality floor, and Auditor reviews every pull request against your own rules.