Three engineering decisions that determine whether a European SaaS company can sell to US customers in two quarters or in six.
Look at this month's European funding recaps and a pattern shows up. Industrial AI and supply-chain software companies keep raising growth rounds, and the use of funds line keeps saying "North American expansion." The sales plan is clear. The engineering plan usually is not, and the first US enterprise security questionnaire is where that gets exposed.
The questionnaire asks where customer data is stored, which engineers can access it, and whether you can show a SOC 2 report. A backend built as one deployment in eu-central-1 has no good answer to the first question for a US customer, and a slow answer to the other two.
The funding announcement does not include the backend work
A single-region deployment is the right call at seed and Series A. One Postgres cluster, one Kubernetes cluster, one Terraform state. Nobody should build multi-region early.
The trouble starts when the second region becomes a revenue requirement. Three things break at once.
The first is latency. A round trip between Frankfurt and the US East Coast is roughly 90 ms before your application does any work. An ML-backed UI that makes six sequential API calls to render a dashboard turns that into half a second of pure network time. Industrial users on a plant floor in Ohio will notice.
The second problem is data location. US manufacturers often want their operational data to stay in the US, in the same way European customers want it to stay in the EU. For personal data, GDPR governs transfers out of the EU, and the EU-US Data Privacy Framework covers certified US recipients. For industrial data that is not personal, there is no statute, but there is a contract clause, and your largest prospect will ask for it.
The third is audit scope. SOC 2 Type II reports cover an observation period, commonly three to twelve months. If you decide to pursue one when the first US deal is in procurement, the report will not exist until well after the deal closes. The controls (access reviews, change management, logging) need to be running from the start of the window.
What we've seen when teams retrofit
The failure pattern is consistent across the fast-growing B2B SaaS companies we talk to. The team clones the production stack into a second region by copy-pasting Terraform, then discovers the application assumes a single database everywhere.
Cross-tenant queries live in the admin panel. A background job joins customer tables with a shared reference table. Feature flags are read from a table in the one Postgres instance. Each of these is a small fix in isolation. Together they are a quarter of work for the people who also own the roadmap, which is the quarter the company promised US revenue.
The teams that move quickly treat this as a bounded platform project with its own owners. It needs infrastructure and backend skills, mostly Terraform, Kubernetes, PostgreSQL and a Node.js or Python service layer. In our model, those are roles we hire for and embed in 3 to 4 weeks, so the project does not have to compete with product work for the same five people.
Build cells, not a global cluster
Our recommendation is a cell architecture. Each region runs a complete, independent copy of the data plane. A thin global control plane knows which tenant lives in which cell, and nothing else.
Global control plane
(tenant directory, auth, billing)
| |
+--------+ +--------+
| |
Cell eu-1 (eu-central-1) Cell us-1 (us-east-1)
API + workers API + workers
Postgres (tenant data) Postgres (tenant data)
Model serving Model serving
Object storage Object storage
This is deliberately boring. We prefer it to active-active global databases such as Aurora Global Database or CockroachDB multi-region for this use case, because customers who want data residency do not want their rows replicated elsewhere, and a global write path adds failure modes that a growing engineering team should not own.
Decision 1: Make the region a parameter in Terraform from day one
The cheapest step is to make the stack instantiable per region. Wrap everything in a module, and pass the provider in.
provider "aws" {
alias = "eu"
region = "eu-central-1"
}
provider "aws" {
alias = "us"
region = "us-east-1"
}
module "cell_eu" {
source = "./modules/cell"
providers = { aws = aws.eu }
cell_name = "eu-1"
}
module "cell_us" {
source = "./modules/cell"
providers = { aws = aws.us }
cell_name = "us-1"
}
Keep a separate remote state per cell. A bad terraform apply in the US cell should not be able to lock or corrupt the EU state, and your blast radius stays at one region.
Decision 2: Route by tenant, resolved in one place
Every request needs a tenant ID, usually as a claim in the JWT. The control plane maps that ID to a cell. In a NestJS gateway this is a small service.
@Injectable()
export class CellRouter {
constructor(private readonly directory: TenantDirectory) {}
async resolve(tenantId: string): Promise<string> {
const cell = await this.directory.cellFor(tenantId); // "eu-1" | "us-1"
if (!cell) throw new NotFoundException('unknown tenant');
return `https://${cell}.api.internal.example.com`;
}
}
The directory is a tiny table: tenant ID, cell, created at. It is the only global data store, it holds no customer content, and it is cached aggressively. Once a tenant is pinned to a cell, moving it is an explicit migration, not an accident of load balancing.
Decision 3: Promote models and images by digest, per cell
If you serve ML models, the artifact needs the same discipline as code. Deploy container images by digest (image@sha256:...), not by tag, and promote the same digest through eu-1 and then us-1. Store the model version in the deployment config, so you can answer "which model produced this forecast" for a given tenant at a given date.
Without this, two regions slowly drift. The EU cell runs a model retrained last week, the US cell runs the previous one, and a customer support ticket turns into a two-day investigation.
What to do before the first US deal
Pull the cross-tenant queries out first. Grep the codebase for joins that span tenant tables and for anything in an admin tool that reads all tenants at once. Those are the queries that cannot survive cells.
Start collecting SOC 2 evidence early, even if the audit is later. Access reviews, pull request approvals and infrastructure change logs are cheap to produce if they are automated in GitHub and Terraform from the start, and expensive to reconstruct.
Run a game day. Take the US cell down in staging and confirm the EU cell is unaffected. If it is not, you have found your hidden global dependency before a customer did.
Key Takeaways
- Single-region is correct early. The mistake is leaving the application coupled to it after a US-facing round is announced.
- Cells with a thin global tenant directory give you data residency without a global database, and they keep the failure domain to one region.
- Make region a Terraform module parameter, deploy by image digest, and pin each tenant to a cell. All three are cheap before the second region and painful after.
- Cross-tenant queries and shared reference tables are the real work. Find them before you promise a date.
- SOC 2 Type II is a time window. Controls that start late push your first report out by the same amount.
SifrVentures builds dedicated engineering teams for tech companies. Based in Berlin. Learn how we work | Read more on our blog
Top comments (0)