Docdeploymill://docs/shared-responsibility

Shared Responsibility Model

Last updated: June 12, 2026

DeployMill is a control plane: it builds, deploys, and operates your web apps on managed infrastructure, driven by you and by the AI agent you connect. Like every cloud platform, that creates a boundary. Some things only we can secure, some things only you can secure, and a few sit genuinely in between. This page draws that boundary explicitly, so neither side assumes the other is covering something nobody is.

The short version: **DeployMill is responsible for the security and availability of the platform. You are responsible for what you build, what you store, and what you instruct your agent to do on the platform.**

This page pairs with Trust & Security (how we secure our side) and AI Agent Access & Safety (what a connected agent can and cannot do).

Why this model exists

When an autonomous agent can deploy to production, "who is responsible?" stops being a theoretical question. DeployMill's answer is structural: the platform enforces hard guardrails (tenant isolation, the zero-readback secret vault, health-gated deploys with auto-rollback, the append-only audit trail), and within those guardrails the agent acts on your instructions, under your identity. The guardrails are our responsibility. The instructions are yours.

Responsibility matrix

Area	DeployMill's responsibility	Your responsibility
Physical & host infrastructure, Kubernetes platform	Operate, patch, and secure the hosts and the Kubernetes (k3s) platform that runs tenant apps; harden the nodes; manage the container build and rollout pipeline	None. You never touch the cluster
Network & tenant isolation	Enforce hard per-organization isolation so no tenant can reach another's apps, data, secrets, or logs; provision and terminate TLS for app traffic	Don't attempt to circumvent isolation; report any suspected gap to [email protected]
Control-plane application	Secure the DeployMill server itself: the MCP tool surface, the REST API, the dashboard, input validation, dependency patching, and keeping backend infrastructure credentials (kubeconfig, registry tokens, database/storage/vault keys) server-side and out of every tool response	Use the platform through its supported surfaces (MCP, REST API, dashboard)
Platform authentication (OAuth / SSO)	Operate the OAuth flow, issue short-lived workspace-scoped tokens, support SSO configuration, enforce role-based access within your workspace	Protect your sign-in credentials and devices; configure SSO correctly for your org; assign roles deliberately; remove members who leave
Secrets vault & encryption	Store secrets AES-256-GCM-encrypted; enforce the zero-readback design (no tool returns a secret value; values never reach an agent transcript); inject values server-side only; provide the single-use browser hand-off for entry	Decide which secrets exist and what their values are; enter values through the hand-off (never paste them to your agent); rotate credentials you own when they may be exposed
Platform availability & platform metadata	Keep the control plane available per the SLA; back up platform metadata (accounts, orgs, app/preview configuration, the audit trail, the encrypted vault)	Keep your own copy of anything you'd need to rebuild elsewhere. Your code is already in your repo, and `.deploymill/project.json` is the portable description of your app
Your application code	Build and deploy exactly what's in your repo; provide health-gated rollouts and rollback	Everything about the code itself: correctness, quality, licensing, what it does to its users, whether a human or your agent wrote it
Your application data & its backups	Provision and operate the managed database and object storage primitives with platform-default durability; isolate preview data from production (copy-on-write branches, fresh volumes/buckets)	The data itself: its correctness, schema migrations, retention, and any backup/restore regime beyond platform defaults that your business requires. If losing it would hurt, back it up
What you instruct your AI agent to do	Enforce the agent guardrails (workspace-scoped tokens, no secret readback, no infra credentials, auto-rollback, dry-run plans, audit trail). See AI Agent Access & Safety	The instructions and their consequences: the agent acts on your behalf, and the human account owner is accountable for its actions. Review what it deploys, especially to production
Application-level security	Platform-level isolation and TLS up to your app's front door	Your app's own authentication and authorization, session handling, input validation, dependency patching, and secure handling of its users' data
Env vars & secret usage	Secure storage and transport of values; never leak them through the tool surface or logs of ours	Choose the values, decide which app gets which secret, avoid putting secrets in plain env vars (use the vault), and avoid logging them from inside your own app
Custom domains & DNS	Provision and renew TLS, route traffic, host `*.deploymill.app` subdomains	Own and manage DNS records at your registrar for custom domains; point them where the platform instructs; keep registrar access secure
Compliance of your app & its end users	Be a documented, auditable platform layer (Subprocessors, DPA, audit trail) you can build a compliance story on	Your app's own legal and regulatory obligations: privacy notices to your users, consent, data-subject requests, sector rules (HIPAA, PCI, etc.). DeployMill being well-run does not make your app compliant
Acceptable use	Define and enforce the Acceptable Use Policy	Comply with it for everything you deploy, whether by hand or through your agent

Previews vs. production

The preview/production split is part of how responsibility stays manageable in practice, so it's worth stating plainly:

DeployMill guarantees the isolation. Every preview gets a copy-on-write database branch and a fresh volume and bucket. Nothing a preview does, yours or your agent's, can touch production data. Production deploys are health-gated, and a failed gate rolls back automatically.
You (and your agent) choose the workflow. The safe path is previews first, dry-run reconcile plans before applying configuration changes, then production. The platform makes that path easy and the unsafe paths bounded, but choosing to skip it is a choice you own.

In one sentence

We keep the platform secure, isolated, and available. You keep your code, your data, your credentials, and your agent's instructions sound. The audit trail keeps everyone honest.