Security
Architecture

Why Forte Requires VM Isolation for Customer Code

The security requirements behind how we build and run your applications: VM isolation, least privilege, and independent access controls.

Forte TeamPublished November 13, 20266 min read

When you deploy an application, you give a platform permission to execute your code and handle the credentials that code needs. Other customers give it the same permission. Some of those customers may be trying to attack it.

That is the environment we design Forte for. Our security stance starts with a requirement: wherever we execute untrusted customer code, it must have VM-level isolation from other customers and the platform's privileged systems. This applies to builds as well as running applications.

VM isolation must work alongside narrowly scoped credentials, restricted network access, and authorization at each service boundary. Each control has a job. A failure in one must encounter a separate control that limits the damage.

Forte was founded by former staff infrastructure engineers from AWS and Meta, with experience reviewing infrastructure security at AWS. That experience informs our standards. Customers should be able to evaluate the actual boundaries behind those standards and the evidence that supports them. About Forte

We assume customer code can be hostile

A build can run package-install scripts, download tools, execute a Dockerfile, and invoke a compiler. A running application can issue network requests and exercise the operating system. Both are places where an attacker can submit code designed to find a way out.

The platform must provide useful capabilities while containing them. Detecting an abusive account is valuable, but protecting other customers cannot depend on recognizing that account before it tries something new.

Our design requirement is that a malicious customer can attack the environment assigned to their own work without inheriting access to someone else's environment. Source workspaces, temporary files, artifacts, credentials, and network paths all need to respect that boundary.

The VM boundary belongs between customers

Ordinary containers share a host kernel. Filesystem isolation and container permissions impose useful restrictions, but they do not create a separate guest kernel or a hardware virtualization boundary.

We require that additional boundary for mutually untrusted customer code. Placing unrelated customers' containers together inside one VM does not satisfy that requirement. The VM boundary must separate their execution environments.

This does not require a separate physical server for every customer. Hardware virtualization allows workloads to share a physical machine while keeping separate guest environments. Lightweight virtual machines, often called microVMs, make that separation practical for application platforms.

AWS describes hardware virtualization around individual Fargate tasks as its strong-isolation model. Our position is that this class of boundary belongs in the foundation of customer compute. AWS's Fargate isolation guidance

For running Forte Services and server-side application workloads, our published policy is that different customers' code does not execute in the same VM. Our build architecture likewise gives each build its own short-lived VM. Filesystem restrictions and container controls operate inside that additional boundary. Forte's workload-isolation policy

Builds get the same seriousness as production

Treating builds as harmless preparation creates a dangerous exception. A build already executes code and may receive sensitive inputs. Its temporary nature does not reduce the need to isolate it while it runs.

Our requirements cover the entire build lifecycle. The workspace must belong to the assigned build. Storage and cache access must preserve customer boundaries. Credentials must authorize the work that build actually needs. When the environment is discarded, another customer's build must not inherit its files or secrets.

An ephemeral VM helps make the execution boundary and its lifetime explicit. The identity, storage, and network policies around it still have to enforce the same limits. A machine that exists for five minutes can misuse an overpowered credential immediately.

A credential has a specific job

We apply least privilege as a requirement for each workload and service identity. Permissions must identify the resources and operations needed for that identity's job. Being issued by Forte, running on a Forte machine, or arriving from an internal network must not grant unrelated authority.

A build that publishes an image needs access to its authorized destination. It should not gain permission to inspect another customer's build history, retrieve platform secrets, or administer production infrastructure.

The receiving service has a responsibility here too. It must authorize the requested action on the requested resource. A valid token establishes an identity; it does not justify accepting every operation that identity attempts.

Temporary credentials reduce how long a stolen credential can be reused. We also require controls on who can obtain them and what they authorize. Their short lifetime cannot compensate for an overly broad trust relationship. AWS's temporary-credential documentation

The control plane needs its own protection

The control plane is the set of systems that schedules builds, provisions workloads, and manages the platform. Those systems need more authority than a customer's application. That difference must be reflected in execution placement, credentials, network access, and authorization.

Our stance is that customer execution must not inherit control-plane authority. A connection between two components needs an explicit purpose and explicit permission. A private network can limit reachability, but a service still needs to enforce who may use it and for which operations.

The same reasoning applies to secrets. Storing encrypted values is one part of their protection. The right to retrieve them, the right to decrypt them, and the scope of each right must also be controlled. A review has to examine what happens when one of those identities is compromised. AWS KMS access controls

These requirements have to be testable

For a security-minded team, a provider should be able to explain the boundary and the evidence behind it. This is the standard we ask customers to apply to Forte:

AreaForte's security requirementWhat the review should establish
Build executionA separate VM boundary for each untrusted build.Placement, workspace lifetime, and storage or cache access preserve isolation.
Runtime executionDifferent customers' code does not share a VM.Workload placement matches the documented isolation model.
CredentialsAuthority is limited to the workload's necessary operations and resources.Unrelated resources and operations reject the identity.
Platform operationsCustomer execution is separated from privileged control-plane access.Network and identity controls independently restrict access.
SecretsRetrieval, decryption, and injection have explicit scopes.A workload receives only the secrets it is authorized to use.

Security review also has to cover changes over time. New build modes, storage systems, regions, and operational tools must preserve the requirements. A protection that applies to the main path but disappears in an exception is an incomplete boundary.

Your application still has responsibilities

VM isolation protects boundaries between execution environments. Your application can still expose its own data through an authorization bug, a vulnerable dependency, or a secret printed to its logs. Code that legitimately receives a credential can use that credential, so it needs appropriately limited permissions from its issuer too.

Forte's responsibility is to operate the platform controls we document. Your team remains responsible for application authorization, dependency choices, and the credentials you provide. Clear responsibility makes a security evaluation more useful because it identifies who can actually fix each risk.

If your team requires VM isolation and defense in depth, those are requirements we share. Start with Forte's security controls and responsibilities and examine the boundaries that matter to your application. Bring your requirements to a technical evaluation through Forte Support.

Evaluate Forte's isolation model

Walk through the execution, identity, and network boundaries relevant to your application with our team.

Railway's Breach Shouldn't Have Been Possible
Security
Architecture

Railway's Breach Shouldn't Have Been Possible

Customer builds shared a VM, and one stolen build credential led to other customers' secrets. Those are architectural failures, not zero-day exploits. Our founders spent 30+ combined years as security leaders and staff engineers at AWS and Meta.

6 min read
Move Your SaaS to Forte One Part at a Time
Migration
Operations

Move Your SaaS to Forte One Part at a Time

Move your backend to Forte while keeping your current database and login. Learn what to test, how to move traffic, and how to prepare to switch back.

7 min read