Custom Apps
Custom Apps are interactive tools you build with AI inside Insulin.
What Are Custom Apps?
A Custom App is a reusable interface, dashboard, form, or workflow tool generated and edited with the Insulin app builder. Use a Custom App when a workflow needs more structure than a chat answer, such as a revenue dashboard, a deal review tool, a co-sell tracker, or an internal operations screen.
Custom Apps are different from built-in Insulin apps such as Chat, Jobs, Marketplace, Knowledge Base, Inbox, Settings, Files, Browser, or Git. Built-in apps are part of the Insulin workspace. Custom Apps are apps your team creates, runs, edits, and shares.
When to Use a Custom App
Use a Custom App when you want to:
- Turn a repeated marketplace workflow into a reusable interface
- Build a dashboard or report from connected systems
- Create a form-like tool for sales, operations, or partner workflows
- Combine AI-generated UI with approved integration actions
- Share an internal app with teammates without building a separate product
For one-off questions, use Chat. For repeatable background work, use Jobs. For packaged expertise, use Agents and Marketplace.
Build Dashboards with AI
Custom Apps are the recommended way to build dashboards and reports in Insulin.
As we continue to expand AI-powered analytics, the legacy Analytics experience is being deprecated. As of July 2026, no removal date is committed — existing Analytics dashboards keep working until one is announced. Instead of relying on fixed dashboards, users can create dashboards tailored to their own marketplace workflows using AI.
You can create a dashboard by simply describing what you need in natural language. For example:
- “Show my top customers by marketplace revenue over the last 90 days.”
- “List overdue marketplace payments.”
- “Build an AWS Marketplace revenue dashboard.”
- “Track offer acceptance rates and pending private offers.”
The AI builder generates an interactive dashboard that you can continue refining through conversation or by editing the generated app.
Migration from Analytics
If you currently use the legacy Analytics dashboards, we’ll help you migrate them to AI Custom Apps. Our team can help recreate your existing dashboards as AI Apps while preserving the reports and workflows your team relies on. If you have any questions about migration or need assistance, please contact your Customer Success Manager.
Build Flow
Custom Apps use an AI builder loop:
- Open Custom Apps
- Create a new app or open an existing app in the builder
- Describe what you want the app to do
- Choose a template or start from a prompt
- Select the app scope and allowed integrations
- Review the generated app in the live preview
- Keep iterating in the builder chat until the preview works as expected
- Save the app
The builder keeps a chat history for the app-editing session. You can ask for changes, inspect the preview, and save when the generated app is ready.
Chat mode vs Edit mode
The builder’s message box has two modes, toggled next to the composer:
- Edit (default) — your message modifies the app and produces a new live-preview build. Use this to make changes.
- Chat — the builder answers in prose without touching the app. Use this to ask questions, plan an approach, or sanity-check an idea before you commit to a change.
When you’re in Chat mode and the builder proposes a concrete change, the reply shows an Implement this button. Clicking it switches to Edit mode and sends the suggestion as your next edit — a one-click path from discussion to implementation.
Visual Edit (element inspector)
Once a preview is rendered, a Visual Edit button appears next to the mode toggle. Turn it on, click an element in the live preview, and your next message is scoped to just that element — for example, “make this chart taller” or “change this label.” Press Esc to clear the selection. This is the precise way to refine a specific part of a generated app instead of describing the whole screen.
Choose the AI model
The builder includes a model picker (the sparkle button near the composer) so you can choose which model generates the app. Models are grouped by provider — Anthropic, OpenAI, and Google — and which models appear depends on the app’s ownership:
- Organization apps offer two key sources per model: Suger’s key (Suger’s hosted access, always available) and Your key (your organization’s own connected provider key — BYOK). BYOK rows for providers you haven’t connected are greyed out; connect that provider first to enable them.
- Personal apps show only Your key rows for the providers you’ve connected — the Suger’s key (Suger-hosted) rows are not offered. Connect a provider to add its models.
The model you pick is pinned on the app, so saved apps keep building with the same model.
Templates
Custom Apps can start from first-party templates. Templates provide vetted multi-file source for common analytics and marketplace workflows, then you can customize them in the builder.
Four starter templates are available in the New App panel:
| Template | What it builds |
|---|---|
| Revenue Analytics | A marketplace revenue dashboard — cash-flow and unpaid KPIs, revenue trend, revenue by product, partner, and currency, and top buyers. |
| Offer Metrics | An offer-book performance dashboard that combines the revenue trend and top-buyer widgets with offer counts, pending acceptances, and creation failures. |
| Private Offer Analytics | An offer-pipeline dashboard organized into Overview, Actions, and Logs tabs, with total and accepted-offer KPIs and the acceptance-rate trend. |
| Co-Sell Analytics | A co-sell pipeline dashboard — referrals by status, partner, and owner, creation trend, use-case and lifecycle-stage breakdowns, and an opportunity-by-region table. |
Templates are useful when you want a working starting point before asking AI to tailor the app to your organization. Leave the template unselected to start from a blank app and build it entirely from a prompt.
Multi-File Source
Custom Apps are stored as a source-file map rather than a single text blob. The entry file is App.tsx, and supporting files can hold components, helpers, and data-shaping code.
This lets the builder create more maintainable apps:
- UI code can be split into focused files
- Imported Custom Apps can be tracked as dependencies
- The saved app can be recompiled when dependencies change
- Compile conflicts can be handled before the app is saved
An app can hold up to 20 source files, and each file can be up to 200 KB.
Importing another app
You can reuse another Custom App inside the one you’re building. The builder has an Imported apps panel above the chat: click Import app, pick any app you have access to (grouped into your apps and org apps), and it’s added as a dependency. Each imported row has a Swap action to replace it with a different app and a remove (✕) action to drop it. When you save, Insulin recompiles the app so it picks up the current version of anything it imports.
Preview, Compile, and Safety Checks
The live preview is a working app preview, not a static mock. Before code is rendered or saved, Insulin compiles it and runs safety checks.
The compile and safety process can report:
| Result | Meaning |
|---|---|
| Compiled code | The app built successfully and can be previewed or saved. |
| Safety errors | The app contains blocked patterns and must be revised. |
| Mock data warnings | The app appears to rely on hardcoded or placeholder data. |
| Compile error | The generated source did not compile and needs another edit. |
The builder can also run a visual review. Visual review uses the rendered app preview, screenshots, runtime logs, network activity, and user prompt to decide whether the output matches the request or needs another edit.
Integrations and Sensitivity Tiers
Custom Apps can be allowed to use connected systems. Each configured integration includes sensitivity tiers:
| Tier | Use |
|---|---|
| read | Read data from the connected system. |
| write | Create or update data in the connected system. |
| outbound | Send data or trigger outbound actions. |
Only selected integrations and selected sensitivity tiers are available to the app. This keeps an app’s runtime access narrower than the full set of tools your user or organization has connected.
Ownership and Sharing
Custom Apps can be user-level or organization-level.
| Ownership | Behavior |
|---|---|
| User | Private to the creator (labeled Personal in the builder). Use this for personal tools or drafts. |
| Organization | Shareable with teammates. Use this for team workflows and shared dashboards. |
Sharing an app
Only organization-level apps can be shared, and the two ways to share combine:
- Share with the entire organization — turn on Share with entire organization and pick a default role for every member. Org-wide sharing offers Editor, User, or Viewer.
- Share with specific users — select a user and assign a role. Individual sharing offers Admin, Editor, User, or Viewer.
A member’s effective access is the higher of the two, so you can share an app org-wide as Viewer and grant Editor or Admin to the few people who maintain it.
| Role | Run & interact | Edit & save | Manage sharing | Delete |
|---|---|---|---|---|
| Owner | Yes | Yes | Yes | Yes |
| Admin | Yes | Yes | Yes | No |
| Editor | Yes | Yes | No | No |
| User | Yes | No | No | No |
| Viewer | View only | No | No | No |
The Owner is the app’s creator and is the only role that can delete the app.
Finding and managing your apps
Saved Custom Apps appear in the Custom Apps sidebar, split into Org Apps (organization-level apps shared with you) and My Apps (your personal apps). A search box filters both lists by name or description.
Right-click any app in the sidebar for a context menu. The available actions depend on your role:
- Edit App — open the app in the builder
- Add to Desktop — pin the app to the Insulin desktop as an icon so you can launch it directly
- Share App — open the Share dialog (organization apps only)
- Delete App — permanently remove the app
Running a Saved App
When a Custom App is saved, Insulin stores the compiled bundle and the normalized integration configuration. Running the app uses the saved compiled code and enforces the configured integration access at runtime.
If an app has no compiled code yet, open it in the builder, generate or fix the app, and save it before using it as a working tool.
How Custom Apps Fit With Insulin
Custom Apps work best alongside the rest of Insulin:
- Use Agents to define the expertise behind a workflow
- Use Marketplace to install reusable agents or skills before building
- Use Jobs for scheduled or event-triggered runs
- Use Channels when teammates need to discuss app output with agents
- Use knowledge bases and connected systems to ground the app in your organization’s data