How team apps are hosted

Where team apps run, how they are isolated and limited, how their base images stay current with automatic rollback, how a scanner maps findings to an app, and how data, secrets and network access are handled. For IT and security teams.

Enterprise, for IT

Team apps are part of the Enterprise plan. This page is for the IT and security teams that run the runners and answer questions about them.

Teams build small apps with kanman: dashboards, tools, forms, reports. This page explains where those apps run and what keeps them contained. How people’s browsers reach them is on Let people reach apps directly.

Where apps run

Team apps run only on the team’s own runners, inside your network. They never run in kanman Cloud. A team without a runner can build an app, but it waits until a runner is there.

Each app has one runner as its home: the runner that holds its data. Every start, backup and request for the app goes to that runner. With more than one runner, see Backups and handover.

Static and server apps

Kind What runs
Static app Files only (HTML, scripts, styles). The runner’s app gateway serves the files. No process and no container run, so there is no image to update.
Server app A program that answers on a port: Node.js, Python, or anything with its own Dockerfile. It runs in a container on the runner, one container per app.

On a runner without Docker, Node.js and Python apps run in a sandbox with a network of its own instead of a container. Apps with their own Dockerfile need Docker.

Supported languages and runtimes

App Image it runs on
Node.js (a package.json with a start script or a known web framework) node:24-bookworm
Python (Django, Flask, FastAPI, or a Procfile) python:3.12-bookworm
Its own Dockerfile (any language; the port comes from EXPOSE) Built on the runner from the Dockerfile
Static site (an index.html, or a build step that produces one) None

kanman detects the kind from the app’s files. Dependencies are installed in the app’s own folder during its start.

Isolation and limits

Each server app runs in its own container with:

  • 1 CPU and 1 GB of memory, and at most 512 processes.
  • All Linux capabilities dropped and no privilege escalation (no-new-privileges).
  • Node.js and Python apps run as the runner’s own user account, not as the image’s root user.
  • Its own internal network, no published port and no host networking.
  • Restart on a crash, up to three times.
  • Install, build, migrations and start must finish within 15 minutes.

The app sees only its own files, its own data folder and the variables kanman passes in. It sees nothing of the runner: no runner secrets, no other app’s files.

Base images and the daily update

Every container runs on an image that is pinned per app on its runner. A new version of node:24-bookworm on the registry never changes a running app by itself.

Once a day, in the app’s quietest hour (from when people open it), kanman updates its base image:

  1. The runner pulls the base image again. An app with its own Dockerfile is rebuilt with --pull.
  2. If the image did not change, nothing happens.
  3. If it changed, kanman checks the app on the image it runs now, restarts it on the new image and checks it again, the same check as after every start.
  4. If the app does not come up, or a check that passed before now fails, the runner puts the app back on the image before. It keeps that image tagged locally, so the rollback works without the registry. The app’s owner is told once, and that update is not tried again; the next base update is.

Updates run one app at a time on each runner. Without usage data, they run at 03:00 in the team’s timezone, or at 03:00 UTC when the team has none. Static apps have no image and are not affected.

Scanning

Run your own scanner (for example Trivy or Grype) on the runner host. kanman labels every container it starts, so findings map to an app:

Label Value
kanman.runtime instance on every container kanman starts
kanman.app.id The app’s id on the runner
kanman.app.version The app version that runs
kanman.app.base The base image, for example node:24-bookworm
kanman.app.base-digest The base image’s registry digest (sha256:...)
kanman.app.image For an app with its own Dockerfile: the built image’s id

For example, docker ps --filter label=kanman.runtime=instance --format '{{.Names}} {{.Image}} {{.Label "kanman.app.base-digest"}}' lists the app containers with their base digests. A Node.js or Python app’s image is tagged kanman-base-<app id>:live, an app with its own Dockerfile kanman-app-<app id>; scan those tags.

The app’s page shows the same in kanman’s check > Image: the base, its full digest and, for a Dockerfile app, the built image’s id, when the last update check ran, and an update that was rolled back. People in the owning team can copy the digest from there to match a finding.

Data

A server app keeps its data in its own SQLite store on its home runner, mounted at /data inside the container (the variable KANMAN_STORE names the file). An app that brings its own SQLite file keeps it as its store. Data survives restarts, new versions and base image updates.

  • Backups: hourly, and before every change to the store’s structure (a migration).
  • Failed migration: the backup taken just before is restored, and the version before stays live.
  • Rollback: rolling back an app brings its code and data back together; the data as it is at that moment is backed up first, so nothing is lost.

Backups and handover

Set KANMAN_APP_BACKUP_ROOT on every runner to a folder all runners reach, such as a network share. Backups then go there. When an app’s home is removed or stays offline for 15 minutes, another runner takes the app over and restores the newest backup. Without a shared folder, the app waits for its home runner; kanman never starts it elsewhere with different data.

A database your IT runs

An app can use a database you operate instead of its own store. Its host must be approved for the app (see Network), and its connection settings reach the app as variables: set them under Settings > Environment and secrets, with the password as a secret (see Secrets).

Secrets

  • An app gets its settings, keys and tokens as environment variables when it starts. They are never written into an image or into the app’s files.
  • Where to set them: open the app, then Settings > Environment and secrets. The app’s owner and the team’s leads can add, edit and remove variables there; everyone else on the team sees the names only. Names use capital letters, digits and underscores. Names the runner sets itself (such as PORT, proxy settings or KANMAN_...) are refused.
  • Secret values are write-only. A variable marked Secret is shown masked after saving and never sent back to a browser. You can replace it, not read it. A plain variable shows its value to the people who may change the app. Every value is stored encrypted.
  • Each change restarts the live app with the new values and runs the same check as after every start. If the app does not start with the change, kanman puts the values back as they were, starts it again and tells the owner.
  • Credentials the owner sets are allowed. A live app usually needs real credentials, so a value the owner or a lead set (or kept) passes even when it looks like a key, a token or a connection string with a password.
  • The runner’s own secrets are never passed. A value that contains one of the runner’s own secrets is left out, and so is a name the runner sets itself. The settings show which variable the last start left out and why, by name only.
  • When someone uploads an app with a key or token in its code, kanman holds it aside, encrypted, and asks the owner. With a yes, it moves into the app’s environment; otherwise it is deleted.
  • Who added, changed or removed which variable, and when, is recorded in the team’s audit log, by name only, never with the value.
  • Previews of merge requests stay stricter: kanman refuses variables whose name says production (PROD_*, *_PRODUCTION, LIVE_*), names the team lists as production, values that are one of the runner’s own secrets, and values shaped like a live credential (cloud keys, live payment keys, private keys, code host tokens). Refused variables are dropped; the preview starts without them.
  • Settings files of other environments (.env.production, .env.local) are removed before anything runs.

Network

  • Outgoing: denied by default. Each app’s container is on a network of its own whose only way out is kanman’s egress proxy on the runner. During the install, only the package registries are reachable (npm, PyPI); after that, only the hosts approved for that app. Hosts the team lists as production are never reachable. This is enforced by the network on the runner, not by the app.
  • Hosts an app tried to reach that no rule allows are blocked and turned into questions for the owner. An approval may need a lead, depending on the team’s rules.
  • Incoming: only through kanman. No container publishes a port. The runner’s app gateway is the only way in, and it admits only people kanman lets in, each with their own rights. Routes the owner approved for outside callers (a webhook, for example) are the only exception.
  • How browsers get to the gateway is set per workspace: through kanman (the default) or directly at your own HTTPS address. See Let people reach apps directly.

Related: Hosting and data residency, Sandbox and secrets, Self-hosted runner.

Last updated: January 1, 0001

Open kanman