A data app is a small program you build in your own repository, such as a Streamlit dashboard, an HTTP service, or a static single-page app, that Dippr runs for you and puts on the Live Apps page. It runs inside your tenant’s data plane, next to your query engines, and every request it makes to the engine runs as the person using the app, not as some shared service account. That last part is the whole point. Two people can open the same app and see different rows, with zero code in the app to make that happen: the platform injects each user’s identity into every request, and your query engine enforces access the same way it would if that person had typed the SQL themselves. This is called invoker mode, and in v1 it’s the only mode there is. Each query is limited to the current viewer’s grants intersected with the installed consent ceiling. App code is trusted, like spreadsheet macros: a server can retain or redistribute rows it previously received from another viewer. Browser hardening does not fully confine trusted app code.

Building one

You build an app with the dip CLI’s dip app new command, which scaffolds a working app with the Altimate SDK already vendored in. Four runtimes are available: See Build a data app and the dip app commands for the full walkthrough. For your first app, start with Build and share your first app, which goes from one request to your agent to a colleague opening the link. If your tenant has no live apps yet, the Live Apps page itself walks you through the same three commands: install dip and sign in, scaffold with dip app new, then dip app build && dip app push. The app registers itself and appears on the page within seconds of a successful push.

The lifecycle

  1. Scaffold the app (dip app new).
  2. Check it locally: manifest validity, drift, and a scan that refuses a bundled database driver (dip app check).
  3. Develop against your own real query engine, as yourself, before you ever build an image (dip app dev).
  4. Ship it: either push a built image to your tenant’s registry, where it registers itself automatically, or bring your own image hosted elsewhere and register it by hand. Every push that completes shows up in the Publish history tab on the Live Apps page, with the outcome next to it; a push that fails before the image lands has no row there — its error prints in the terminal where you ran dip app push. See Registry troubleshooting.
  5. Install. The owner or an app administrator reviews what the app asks to access and consents to it, or leaves some of it unchecked, which keeps the app from running at all until every requested capability is granted.
  6. Active. Once consent is complete, the app starts and appears at its own URL and inside the console’s embedded viewer.
  7. Use it. Anyone in your tenant with access to the Live Apps page can open it. It suspends after a period of inactivity and wakes again on the next request.
See Build and push an image, Install an app, and Use an installed app for each stage in detail.

Who does what

An administrator can turn off Publish own apps and Manage own apps per role in Settings → Roles & permissions. Denies apply through role inheritance and across a member’s roles. Turning them off also prevents narrow delete, park and uninstall actions; broad administration remains available. Preview has its own independent permission. Console controls use your permissions and the app’s owner to show available actions. Every action checks current permissions again when submitted. See Own-app role settings.

Static apps

A static app is one you build with dip app new --runtime frontend. Its pages are files that Dippr serves for you, so the app’s own code never runs on a server, and it only reads data. Every version a member publishes, installs or moves to must be static:
  • Each component declares staticRoot in the manifest, the folder of built files inside your image.
  • No data capability asks for write access.
A Streamlit or Python app, or any app that runs its own server, publishes only with a Data engineer’s broad publishing permission. If you publish one without it, the push or registration is refused with:
The same refusal applies when you install, wake, change consent or move an installation to a version that is not static, even one someone else published. You can always park or uninstall your own app.

What an app’s URL looks like

An installed app gets its own address: a subdomain scoped to that specific installation, not to the app’s name. Because the address is tied to the installation rather than the name, renaming an app later never breaks a bookmark or an embed. On the Live Apps page, opening an app takes you to that address inside an embedded viewer at /apps/<app-name>/view; the app also has its detail page at /apps/<app-name> for installing, reviewing consent and managing its lifecycle. For a static app, Open in new tab opens /apps/<app-name>/full, where the app fills the whole tab with no console menu around it. In a current browser, a static app is shown only inside the console’s viewer. Opening its own address in a browser tab takes you to /apps/<app-name>/full for that app, so the address still works as a link to share. An app that runs its own server opens on its own at its address, and Open in new tab takes you there.

What data apps don’t do yet

A few things are deliberately out of scope for now, reserved for later rather than silently missing:
  • No unattended or scheduled apps. Every app query runs as a specific person opening it in their browser. There’s no mode today for an app to run on its own, on a schedule, with no one watching.
  • One process per app. An app’s manifest can describe more than one container, but only one is accepted when you register or install it. An app runs as a single pod.
  • No embedding outside your own tenant’s console. You can open an app inside Dippr’s console today; embedding it in a page you host yourself, outside Dippr, is proposed but not built.

Build a data app

Scaffold an app, read who’s calling it, and test it against your real data.

Write the app manifest

Every field a data app declares, and what the platform validates.