Vibe Engines
YouTube

Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path

Deployment Targets (Cloud → Air-Gapped)

Where will it actually run? The tradeoffs across SaaS, the customer’s cloud/VPC, on-prem, and air-gapped — and what each costs you.

Where software runs decides most of what follows: who holds the data, how updates ship, which models you can use, and how you debug at 2 a.m. The targets form a spectrum from your SaaS to air-gapped; each step toward the customer hands them more control and costs you more effort to deliver and support.

Ask “where can this run, and who approves it?” in the first meeting. Then build for the most restrictive target you might face — containers, configuration instead of forks, no hidden internet dependencies — because retrofitting portability is far harder than starting with it.

Your SaaSdata: your cloudupdates: any timemodel: any APITheir VPCdata: their cloudupdates: approvedmodel: cloud APIOn-premdata: their DCupdates: scheduledmodel: self-hostAir-gappeddata: never leavesupdates: by mediamodel: self-hosteach step right: more control for them, more work for you
Four points on one spectrum. Single-tenant SaaS and BYOC sit between the first two. Each step right gives the customer more control and costs you more to ship, update and debug.

The targets

Your SaaS (multi-tenant)
Fastest to ship + update. Blocked when data can’t leave the customer’s network.
Customer cloud / VPC
Runs in their account. You get cloud tooling but their network + IAM rules.
On-prem
Their hardware/datacenter. You manage installs + updates; no managed services.
Air-gapped
No internet at all. Everything (models, deps, images) ships in by hand. Hardest.
Single-tenant SaaS
a dedicated stack per customer in your cloud — isolation without shipping them software
BYOC
bring your own cloud: your control plane, their data plane in their account, run remotely by you

What changes as you move right

Data egress
SaaS: leaves. VPC: stays in their account. On-prem/air-gap: never leaves.
Updates
SaaS: you push anytime. Air-gap: scheduled, manual, versioned bundles.
Model hosting
Cloud APIs fine on SaaS/VPC; on-prem/air-gap → self-host an open model (vLLM etc.).
Secrets
Their vault, their KMS, their rotation policy — not your .env.
Observability
Your dashboards on SaaS; on-prem you ship logs to their stack or a local one.
Your access
Full on SaaS; on-prem you may get a screen-share and someone else’s hands.
Internet egress
expect an allowlist or none — model APIs, license checks and telemetry may all be blocked
Proxies and custom CAs
set HTTPS_PROXY / NO_PROXY and trust their root certificate, or TLS calls fail
Identity
their SSO (SAML or OIDC) and their directory groups, not your user table
Compliance
a SOC 2 report covers SaaS; FedRAMP, HIPAA or data residency can force VPC or on-prem

Connecting to their network

Private connectivity
AWS PrivateLink, Azure Private Link, GCP Private Service Connect — no public internet
VPC peering
simple routing between two networks — breaks when their IP ranges overlap yours
Cross-account role
an IAM role they create for you, with an external ID and only the permissions you need
Outbound-only agent
software in their network dials out to you — no inbound firewall rules to approve
Customer-managed keys
their KMS key encrypts your data at rest; revoking it cuts you off, by design
Egress allowlist
document every domain your software calls, so their firewall team opens exactly those

Packaging & delivery

Containers + Helm chart
the common denominator for VPC and on-prem Kubernetes installs
Their registry
mirror images into their ECR, ACR, Artifact Registry or Harbor — never pull from yours
Pin by digest
reference images as name@sha256:…, not tags that can move
Signatures and SBOM
sign images (for example with cosign) and ship an SBOM — reviewers increasingly ask
Air-gap bundle
images, charts, model weights, Python wheels and checksums in one versioned archive
Offline licensing
signed license files with an expiry, verified locally — no phone-home
Config, not forks
one values file per site and one codebase — never a customer-specific branch

Operating it

Support bundle
one command that collects logs, versions and config, secrets redacted, to send you
Version support policy
support the current and previous release; on-prem sites lag months behind
Upgrade path
tested upgrades from every supported version, with migrations and a rollback plan
Backups and DR
agree up front who backs up the data and who tests a restore — usually them
Telemetry
opt-in, documented and minimal; air-gapped sites get none, so ship local dashboards
Remote access
agree on a bastion host or supervised screen-share, with session recording, before you need it

De-risk early

Ask in discovery
“Where can this run, and who approves it?” — it reshapes the whole architecture.
Package portably
Containerize; avoid a single cloud’s managed-only services if on-prem is possible.
Plan the update path
How do you ship v2 to an air-gapped site? Decide before v1.
Least privilege
Request the minimum access; security says yes faster to a small ask.
Environment checklist
OS, Kubernetes version, GPUs, proxy, DNS, registry, storage class — collect before designing
Install early
a week-one install in a copy of their environment beats polished code that never deploys

Cost, effort & pricing

Effort ramp
Each step right roughly multiplies deployment + support effort: SaaS ≪ VPC < on-prem ≪ air-gapped.
Who pays for compute
SaaS: you (bake into price). VPC/on-prem: the customer’s cloud/hardware bill — price the software, not the infra.
Support model
SaaS: you see everything and fix fast. On-prem/air-gap: you debug blind through their team — budget for it.
Price the friction
Air-gapped and on-prem deals should carry a premium — they cost far more to deliver and maintain.
GPU reality
Self-hosting an open model on-prem means sizing, buying, and babysitting GPUs — a real project, not a checkbox.

Worked example: moving a pilot from your SaaS into a bank’s AWS account

A document-extraction pilot ran in your multi-tenant SaaS on anonymized samples. For production, the bank’s security team rules that real documents may not leave their AWS account. That moves you one step right, into their VPC. Here is what changed, in the order it bit.

  1. Model hosting. The SaaS called a public model API. In their account, calls must go to a model service the bank has approved, or to a self-hosted open model. Re-run the eval set against whichever model you end up with: scores do not carry over between models.
  2. Images. Their EKS cluster cannot pull from your registry. You mirror the images into their ECR and reference them by digest, extractor@sha256:….
  3. Egress. The first install fails because the worker downloads a tokenizer file at startup. You bake it into the image, then write the allowlist: two domains, both of them the bank’s.
  4. TLS. Calls to their document store fail with unable to get local issuer certificate, because their proxy re-signs TLS with an internal CA. You mount their root certificate and put in-VPC hosts in NO_PROXY.
  5. Identity. Your user table goes. Login is now their identity provider over SAML, with roles mapped from two directory groups.
  6. Support. You can no longer see logs. You ship the support-bundle script, and their platform team agrees to run it and send the archive when something breaks.

None of these steps touched the extraction logic. All of them were deployment work, which is why the target belongs in the first discovery call, not in month three.

Recipes

Ship a release to an air-gapped site

# connected side
docker pull registry.example.com/app:2.4.0
docker save registry.example.com/app:2.4.0 -o app-2.4.0.tar
helm package ./charts/app                            # writes app-2.4.0.tgz
shasum -a 256 app-2.4.0.tar app-2.4.0.tgz > SHA256SUMS

# move the files across on approved media, then on the customer side
shasum -a 256 -c SHA256SUMS
docker load -i app-2.4.0.tar
docker tag registry.example.com/app:2.4.0 registry.internal/app:2.4.0
docker push registry.internal/app:2.4.0
helm install app ./app-2.4.0.tgz -f site-values.yaml --set image.repository=registry.internal/app

Rehearse the bundle on a disconnected machine first. What breaks is always something that quietly downloaded at runtime — a model file, a tokenizer, a pip package, a font.

Pick the target from the customer’s answers

Can data leave their network?               no  -> VPC, on-prem or air-gapped
Is there any internet egress at all?        no  -> air-gapped
Do they run Kubernetes, and have GPUs?      no  -> a managed VPC deployment, or they buy hardware
Do they want you to operate it?             yes -> single-tenant SaaS or BYOC
None of these blocks it                         -> multi-tenant SaaS: fastest to ship and update

Ask these in the first meeting and write the answers down with who gave them — a security team overruling a business sponsor in month three is the classic way a deal stalls.

Set up a BYOC cross-account role (AWS, high level)

1. publish a role template: trusted principal = your AWS account, ExternalId = unique per customer
2. the customer creates the role in their account, with only the permissions you document
3. your control plane assumes it:
   aws sts assume-role --role-arn arn:aws:iam::<their-account-id>:role/vendor-deploy \
     --role-session-name deploy --external-id <their-external-id>
4. every action lands in their CloudTrail; they revoke access by deleting the role

The external ID prevents the confused-deputy problem, where another customer tricks your service into assuming this one’s role. Keep the permission list short — it is exactly what their security review will read.

Collect a support bundle from an on-prem install

kubectl -n app get pods -o wide > pods.txt
kubectl -n app get events --sort-by=.lastTimestamp > events.txt
for p in $(kubectl -n app get pods -o name); do
  kubectl -n app logs "$p" --all-containers --since=24h > "logs-$(basename "$p").txt"
done
helm -n app get values app > values.yaml            # review for secrets before sending
tar czf support-bundle-$(date +%Y%m%d).tgz *.txt values.yaml

Ship this as a script with the product so their team can run it without you on the call. Redact before anything leaves their network: Helm values often contain passwords.

When to use it, and when not

Pick the leftmost target the customer’s rules allow. Every step right is slower to ship and costlier to support.

  • Multi-tenant SaaS when data may leave their network and your compliance reports satisfy their review. The default, for speed.
  • Single-tenant SaaS when they need isolation (their own database, their own keys) but will still let you hold the data.
  • BYOC or a VPC install when data must stay in their cloud account. Choose BYOC if they want you to operate it, a VPC install if their team will.
  • On-prem when the data or the regulator requires their own hardware. Budget for GPUs and for upgrades that go through their team.
  • Air-gapped only when there is truly no egress. Confirm it in writing: “no internet” sometimes means “an allowlist nobody has asked for yet”, which is a far cheaper project.

Trade-offs and limits

TargetShipping a fixWhat you can seeModel options
Your SaaSyour own pipeline, any timeeverythingany API
VPC / BYOCthrough their change controlwhat their role grants youcloud APIs they approve, or self-hosted
On-premin their maintenance windowwhat they send youself-hosted open weights
Air-gappeda bundle on approved mediaonly what they describeself-hosted, weights carried in

The hidden cost is version spread. Each on-prem or air-gapped site upgrades on its own schedule, so you end up supporting several releases at once. A “current plus previous” policy caps that, but only if it is written into the contract.

Common mistakes

  • Building on a managed-only service. A queue or database that exists in only one cloud becomes a rewrite when an on-prem customer arrives. Prefer components you can also run in a container.
  • Downloads at runtime. Model weights, tokenizers, pip packages and fonts fetched on first start work on every connected test machine and fail on site. Test the install on a machine with networking turned off.
  • Pulling by tag. app:latest, or even app:2.4, can point to different bytes tomorrow. A digest cannot. Pin by digest for anything a customer runs.
  • Asking for admin. A broad role request triggers a long review. A short, documented permission list is approved faster, and it is what the audit will check anyway.
  • A branch per customer. It feels faster for the first site and turns every later fix into a merge across forks. Put site differences in a values file.
  • Assuming their cluster matches yours. Kubernetes version, storage class, ingress controller and GPU drivers all vary. Collect the environment checklist before you design.

Check yourself

Data may leave the customer’s network, but they want a dedicated database and their own encryption keys, and they do not want to run anything themselves. Which target fits?

Single-tenant SaaS: a dedicated stack in your cloud, combined with Customer-managed keys. Nothing forces their own account, and they want you to operate it. The second recipe’s “want you to operate it?” branch lands there too.

In their VPC, curl to an internal service fails with “SSL certificate problem: unable to get local issuer certificate”. Which row explains it, and what is the fix?

Proxies and custom CAs. A TLS-inspecting proxy re-signs traffic with the company’s own root certificate, which your container does not trust. Add their CA to the container’s trust store, or list hosts that should bypass the proxy in NO_PROXY. Never switch verification off.

You are shipping 2.4.1 to an air-gapped site. Besides the image, what goes in the bundle, and what does the customer run first when it arrives?

The Helm chart, any database migrations, model weights, Python wheels, a license file if it changed, and a SHA256SUMS file (Air-gap bundle). On arrival they run shasum -a 256 -c SHA256SUMS before loading anything.

Two on-prem sites both run registry.internal/app:2.4 but behave differently. Why, and which row prevents it?

A tag can move. The sites pulled 2.4 at different times and got different images. Pin by digest (app@sha256:…) so every site runs exactly the same bytes.

Questions about Deployment Targets (Cloud → Air-Gapped) Cheat Sheet

What is the difference between SaaS, VPC and on-prem deployment?

In SaaS, the vendor runs the software in its own cloud and customers send their data to it, which is the fastest to ship and update but means data leaves the customer’s network. In a VPC deployment, the software runs inside the customer’s own cloud account, so data stays within their boundary while they still get cloud services, though the vendor works within their network and IAM rules. On-prem means the customer’s own servers or data center, with no managed cloud services; the vendor delivers installable packages, and upgrades and debugging go through the customer’s team.

What is an air-gapped deployment?

An air-gapped environment has no connection to the internet at all, and sometimes none to other internal networks either. It is common in defense, intelligence, critical infrastructure and some financial and healthcare settings. Everything the software needs, including container images, model weights, language packages, license files and documentation, must be carried in on approved media and verified with checksums. Nothing can call home, so there is no remote telemetry or license server, and updates arrive as scheduled, versioned bundles. It is the most expensive target to support, so price and plan it accordingly.

What is BYOC (bring your own cloud)?

BYOC is a hybrid model in which the vendor operates the software, but it runs inside the customer’s cloud account. Typically the vendor keeps a control plane in its own environment for upgrades, monitoring and configuration, while the data plane that touches customer data runs in the customer’s account, reached through a narrowly scoped cross-account role or an outbound-only agent. Customers get data residency and their own security controls without operating the software themselves, and vendors keep most of the operational speed of SaaS. The trade-off is a more complex permissions and support model.

How do you update software in an air-gapped environment?

Build a complete, versioned bundle on a connected machine: container images saved as archives, Helm charts or installers, database migrations, model files and dependencies, plus a checksum file and ideally signatures. The customer moves it across through their approved transfer process, verifies the checksums, loads the images into their internal registry and runs the upgrade with their site configuration. Support upgrades from every version you still maintain, test migrations and rollback beforehand, and rehearse the whole process on a disconnected machine, because anything that silently downloads at runtime will fail on site.