Overnight Runtime
The Runtime runs each app isolated, audited, and governed by default. Every call it makes takes one mediated path, gets checked against the policy you approved, and gets logged on the way through. Anything you didn’t allow is denied.
Set it once, for everything.
Identity and approval before deploy are set once for your whole account, and each app’s allowed list is set in its own settings. An app that arrives tomorrow is already under them.
The Overnight Runtime is the enforcement layer of a compliant runtime: one isolated runtime per customer, every call mediated and logged, every app running only the version you approved, and anything you have not explicitly allowed denied by default.
Whatever is not granted has already been refused, including everything nobody thought to write a rule about.
- 01mediation
Every call the software makes takes one path
Every call the app makes to the outside world goes through one checkpoint and is checked against its allowed list, and every request coming in passes the identity check first. An app that tries to go around it reaches nothing.
The boundary sits in the middle of every move the software makes, which is what turns policy from a document into something the code physically cannot get around.
- 02layered enforcement
Enforcement sits underneath the workload, at three layers
Your tenant executes on its own virtualized boundary, with separation enforced beneath the operating system the app can see. There is no default route out, so every outbound call travels the mediated path and an app that opens a socket of its own finds nothing on the other end. Logins for the tools your app connects to never reach it: calls go through Overnight, which holds the token. Other secrets are encrypted and handed to the app only when it runs, and every system call passes through a sandbox first.
This is what settles the question most platform engineers ask second. Code the Refinery never saw is governed exactly the same, because none of these three layers is something a workload can opt out of.
- 03isolation
Every tenant is isolated at rest and in how it runs
Every app gets its own database and credentials, and each customer’s apps run inside a sandboxed boundary of their own. That separation is structural, enforced underneath the code, which matters precisely because a model wrote that code: a dropped tenant check has nothing to reach, and a prompt injection lands inside a boundary that refuses anything you have not explicitly allowed.
The network edge every tenant’s traffic passes through is shared infrastructure. We say so rather than let you assume otherwise, because the isolation claim above is about your data and your workload, not about every component in front of it.
- 04provenance
What runs is exactly what you approved
Every version is stored under a fingerprint that can’t be overwritten, and only a version you approved can go live. Nothing changes underneath you after you sign off.
The Runtime would rather fail loudly than quietly run something you have never seen. That is also what makes the audit trail worth reading, because every entry is tied to a specific build somebody put their name against.
- 05deny by default
Set the controls once, for everything that arrives after
Identity and approval before deploy are set once for your whole account, and each app’s allowed list is set in its own settings. An app that arrives tomorrow is already under them and was never asked to implement any of them itself.
The boundary starts closed. Whatever you have not granted has already been refused, including all the things nobody thought to write a rule about, which is the category that produces incidents.
- 06the record
A complete, exportable audit trail
The Runtime records it all as it happens: every identity check, settings change and approval, every action that changes data, and every call the app makes to the outside world, each with the app, the identity and the person who approved it. Refusals are recorded on the same footing as successes.
When an auditor or a customer asks what touched their data, the answer is already written. You export it and get on with your week.
What an auditor gets → - 07what it costs you
One mediated hop, and your code stays yours
Overhead lands on calls that cross the boundary, where a policy decision has to happen anyway. Work an app does inside its own process runs untouched, so for the internal tools, reports, and data jobs teams build here, the mediated hop is rarely what determines how long anything takes.
Your apps are your own code and they leave with you whenever you want. The audit trail exports too, because a record you cannot take with you is worth little to an auditor in year three.
Run it where you can trust it.
Approve the boundary once. Every app you run inside it inherits the same posture, on day one and on app fifty.