The insurer finishes a long project. The underwriting platform now runs in a private controlled environment: its own cloud network, no public addresses on any service, every outbound connection through an allowlist, certificates from the insurer's own certificate authority, sign-in only through the enterprise identity provider, and model calls only through the LLM gateway. The security review that signed it off ran for weeks.
A month later a performance ticket arrives about the time the quote service spends validating tokens and asking the policy decision point. An engineer proposes a shortcut: "Every caller of the quote service is inside the private network now. Nobody outside can reach it. Can internal callers skip the token check?"
The proposal sounds reasonable, and it is the mistake this page is about. "Inside the network" describes where a packet came from. It does not say which workload sent it, on whose behalf, or whether that workload may read quote Q-5531. Inside the private network sit dozens of workloads: batch jobs, a reporting tool, a build runner, a debugging pod someone forgot to delete. If the quote service trusts all of them, a compromise of any one is a compromise of every quote. This site's own case UW-A04 shows how little it takes: a script inside the network sends one header, x-app-id: svc-cockpit-bff, to a service that trusts it, and receives a quote.
So the question of this page is not "is private networking good?". It is: for each control of a private environment, what does it protect, what does it not, and what risk is left after it?
What a private controlled environment is#
A private controlled environment is a deployment where the organization decides every path in and out: which networks can reach which services, which outside endpoints any workload may call, which certificate authorities are trusted, and which identity provider people and workloads use. A tiny example: the underwriting agent can call the LLM gateway at https://llm-gw.internal.example, and nothing on the public internet, because the network has no route there except through approved endpoints.
Large regulated enterprises build these because auditors ask where data can travel, security teams want fewer doors, and data owners want model providers reached under the organization's agreement, not a personal account.
Before AI. The pattern is old. A data center had a DMZ, an internal network, an outbound proxy that allowed a list of sites, an internal PKI for server certificates, an LDAP or Active Directory domain, and a change advisory board. Teams learned the same lesson then that this page teaches now: a server on the internal network that trusted every internal caller was the first thing an attacker used after getting a foothold.
Plain English. A private network decides who can reach the door. It does not decide who may walk through it, or what they may take once inside.
The idea that location is not identity is a published guideline, not this site's opinion. Guideline (NIST SP 800-207, Zero Trust Architecture, read 2026-11-18): "The entire enterprise private network is not considered an implicit trust zone." The same document asks that the implicit trust zone behind any enforcement point be "as small as possible". The Gateways and zero trust page owns the tenets; this page applies them to the controls of one environment.
The smallest primitive: a network path is not a principal#
The smallest demonstration is one request with no credential, sent from inside the network. The example's services.py function request_path simulates the four hops of the broker's read (caller, API gateway, quote service, database). With the toggle private_network, the caller is a workload inside the network that sends no token and no certificate. It shows what the quote service does with a caller it cannot identify. A successful run proves the service refuses on missing authentication; it does not prove the network is configured well. Run in a scratch copy of examples/uw-auth:
== private own {'status': 401, 'data_returned': False, 'leaked': False}
1 caller | none | unknown | sends | nobody | inside the network; no token, no certificate
2 gateway | none | unknown | bypassed | nobody | internal traffic does not pass the ingress gateway
3 service | none | unknown | deny 401 | pdp R-AZ-01 | no valid authentication: the caller is unknown
4 database | none | none | not reached | nobody | no query
lesson: Being inside the network adds no identity: the service still needs a credential and a decision on the record.
Notice hop 2: internal traffic never passes the ingress API gateway. The only check left is in the quote service, which refuses with 401 because rule R-AZ-01 has no subject to evaluate. Remove it, as the proposal suggests, and nothing stands between any internal workload and the database.
Ten controls, one question each#
A private controlled environment is ten or so controls, each built by a different team. Each one below gets three answers: what it protects, what it does not, and its residual risk, the risk that remains after a control works exactly as designed.
Private network (a VPC or an equivalent virtual network). Services have no public addresses, and only defined subnets can reach them. This protects against scanning and direct attack from the internet. It does not identify any caller inside, and it does not limit what an inside caller can reach once routes exist. Residual risk: any compromised workload in the network has network reach to every service that trusts the network.
Private endpoints. A private endpoint is a network interface inside your private network that connects to a cloud service (object storage, a secrets manager, a model service) without traffic crossing the public internet. It protects the path: data to the cloud service stays on the provider's network. It does not, by default, restrict who uses it. Product (AWS PrivateLink VPC endpoint policies, as documented on 2026-11-18): "The default endpoint policy grants full access to the endpoint", and an endpoint policy "does not override or replace identity-based policies or resource-based policies". Residual risk: without an endpoint policy, a private endpoint is a private road that anyone on the network may drive, to any account at that service, including an account the organization does not own.
Egress control with approved endpoints only. Egress control limits which outside destinations any workload may connect to, usually through a proxy or firewall that allows a named list. It protects against data leaving to an arbitrary host and against malware calling home. It does not judge what is sent to an approved destination. Residual risk: an approved destination that accepts uploads from any account (a public storage service, a model provider reached with someone's personal key) is a way out that the allowlist cannot tell apart from the legitimate use.
Internal certificate authority. An internal CA is a certificate authority the organization runs for its own services and clients, trusted only inside its environment. It lets services prove which host or workload they are, with mutual TLS where both sides present certificates. It does not decide what a verified peer may do: TLS and PKI shows that an established mTLS connection grants no write access (case UW-A20). Residual risk: whoever can request certificates from the CA can become any name the CA will sign, so issuance policy and the CA's own keys become crown jewels. Public CAs are moving away from client certificates, which pushes this work inside. Product (Let's Encrypt, as documented on 2026-11-18): no further certificates with the TLS Client Authentication extended key usage have been issued since 8 July 2026, and "Many uses of client authentication are better served by a private certificate authority."
Enterprise identity provider. The enterprise IdP is the one system that authenticates the organization's people (and often its workloads) and issues their tokens, fed by the HR source of truth. It protects against scattered local accounts and gives one place for MFA, offboarding and sign-in logs. It does not decide record-level access: it says who the underwriter is, not which submission she may decide. Residual risk: the IdP is a single point of trust; a misconfigured federation, an over-broad group or an IdP outage affects every application at once (case UW-A23 shows writes failing closed when no new strong authentication can be obtained).
LLM gateway. The LLM gateway is the one service allowed to call model providers, and the only holder of the provider credential (in the example, svc-llm-gateway). It protects against provider keys scattered across applications and gives one place for model allowlists, budgets and logging. It does not make the model's output trustworthy, and it does not authorize the agent's actions on business records. Residual risk: the gateway sees every prompt, so its logs become a sensitive data store, and a gateway that does not identify each calling application cannot attribute cost or enforce per-application policy. Model providers owns this control.
Internal API gateway. An internal API gateway sits between internal callers and services, validating tokens and route scopes. It protects against unauthenticated and malformed calls and gives one place for rate limits. It does not see the record, so it cannot stop one valid caller reading another tenant's quote (case UW-A03, the gateway-only BOLA hole). Residual risk: any path that skips the gateway, such as a direct call to a service's internal address, meets no check at all unless the service checks too.
Regulated data access. Data the organization's obligations classify as regulated gets extra rules: who may read it, from which environment, for which recorded purpose. It protects the data owner's obligations, but only on paths that enforce it: query, export job, search index, agent tool. Residual risk: copies in indexes, caches, traces and model logs, each needing the same rules (RAG shows this for chunks).
Admin audit. Every privileged action (granting access, changing a network rule, reading a secret, using break-glass) produces an audit record that the administrator cannot alter. It protects the ability to reconstruct who did what. It does not prevent the action. Residual risk: an audit trail nobody reviews is evidence after the fact, not a control; and an audit pipeline that copies tokens or secrets into records creates a new leak (case UW-A24 scans the example's audit log for exactly that). Audit and Privileged access own the details.
Change management. Change management is the process by which a change to code, configuration, network rules or policy is proposed, reviewed by someone other than its author, approved, recorded and released. It protects against one person widening access silently, not against a reviewed change being wrong. Residual risk: emergency changes that skip review, such as a firewall rule opened "temporarily", and reviewers who approve what they cannot read.
Diagram: Ten controls on one path · where each sits and what it can see
Read left to right, from the outside world to the record. The first lane holds the network controls: they see addresses and destinations, never a principal. The second lane holds the identity controls: they prove who a person or workload is, never which record it may touch. The third lane is the request inside the environment: the internal API gateway sees a token and a route, and only the quote service, asking the PDP, sees quote Q-5531 and its tenant. The fourth lane holds the controls that record and govern change. The decision about the record appears in exactly one box.
- Network: who can reach
- private network (VPC): Services have no public addresses; only defined subnets can reach them. Protects against the internet; identifies nobody inside.
- private endpoints: Network interfaces that reach cloud services without the public internet. AWS documents that the default endpoint policy grants full access.
- egress allowlist: Outbound connections only to approved destinations. Cannot tell which account at an approved service receives the data.
- Identity: who is calling
- internal CA (mTLS): Issues workload and host certificates trusted only inside. Authenticates peers; grants no business action.
- enterprise IdP: The one sign-in for people, fed by HR. Says who the underwriter is, not which submission she may decide.
- The request inside
- internal API gateway: Validates tokens and route scopes on its path. Never sees the record, so it cannot stop BOLA (UW-A03).
- quote service asks the PDP: The only place that sees quote Q-5531 with its tenant and asks the policy decision point. A caller with no credential gets 401 (R-AZ-01).
- LLM gateway: The one workload allowed to call model providers. Holds the only provider credential; its prompt logs are sensitive data.
- Record and govern
- regulated data rules: Extra rules for classified data on every path: queries, exports, indexes, caches and logs.
- admin audit: Every privileged action is recorded where the administrator cannot alter it. Evidence, not prevention.
- change management: Network rules, endpoint policies, CA issuance and authorization policy change only through review and a recorded release.
The diagram places the ten controls on one path. The network controls see addresses; only the quote service sees the record, so the decision about Q-5531 can only be made there. The same ten controls side by side:
| Control | What it protects | What it does not | Residual risk |
|---|---|---|---|
| Private network (VPC) | Reach from the internet | Identity of inside callers | Any compromised inside workload reaches every service that trusts the network |
| Private endpoint | The path to a cloud service | Who uses it (default policy: full access) | Use of the endpoint for other accounts unless an endpoint policy restricts it |
| Egress control | Destinations outside | What is sent to an approved destination | Approved services that accept any account become exits |
| Internal CA | Workload and host authentication (mTLS) | What a verified peer may do | Anyone who can obtain certificates can become a name the CA signs |
| Enterprise IdP | One place for sign-in, MFA, offboarding | Record-level authorization | Single point of trust; federation and group mistakes spread everywhere |
| LLM gateway | One holder of the provider credential; model policy | Business authorization; output quality | Prompt logs become sensitive; per-application attribution needs app identity |
| Internal API gateway | Token, audience and scope checks on its path | The record (BOLA, UW-A03) | Paths that bypass it reach unchecked services |
| Regulated data access | The data owner's obligations | Copies in indexes, caches, logs | Each copy needs the same rules |
| Admin audit | Reconstruction of privileged actions | The action itself | Unreviewed trails; secrets copied into records |
| Change management | Silent widening of access | Correctness of approved changes | Emergency bypasses; rubber-stamp reviews |
Read down the third column: no control decides "may this caller read this quote now?". The quote service answers that, with the policy decision point, on the record. The environment makes the callers fewer and the paths shorter. It never makes the decision unnecessary.
Diagram: Four controls · what each protects, what it does not, what is left
Each row is one control of the private environment. Read across: what it protects, what it does not, and the residual risk that remains when it works exactly as designed. The last column is the one design documents leave out. For every row, the record decision about Q-5531 still happens in the quote service.
- Private endpoint
- traffic stays off the internet: Requests to the cloud service travel on the provider's network.
- restrict who uses it: AWS: the default endpoint policy grants full access; endpoint policies do not replace identity or resource policies.
- other accounts reachable: Without a restrictive endpoint policy, the private path can reach resources in accounts the organization does not own.
- Egress allowlist
- unknown hosts blocked: Workloads cannot connect to arbitrary destinations.
- judge what is sent, or to whom: An approved host receives whatever is sent, for any account.
- approved hosts as exits: Data can leave through any approved service that accepts uploads from any account.
- Internal CA
- which workload is calling: mTLS proves the peer holds the private key for a certificate the internal CA signed.
- what the peer may do: A verified peer still needs a policy decision on the record (UW-A20).
- issuance is an access path: Whoever can obtain a certificate for a name becomes that name.
- LLM gateway
- one credential, one model policy: Provider credential held in one place; model allowlist and budgets enforced there.
- authorize business actions: The gateway decides which model an application may call, not whether the agent may record a decision.
- prompt logs are sensitive data: Every prompt passes the gateway; its logs hold submission details and retrieved text.
The grid repeats four of the controls. Its last column is the one most design documents leave out.
The insurance example: a script inside the network#
The hops lab shows the broker's request, hop by hop. With the preset private, the caller is a workload inside the network with no credential. Switch the forged x-app-id toggle on and off, and the "require mTLS peer identity" toggle, to see the three cases below.
For a reader without JavaScript, the recorded run (status, and who decided at the quote service):
| Preset | Own quote Q-5531 | Other tenant's Q-6620 | What it shows |
|---|---|---|---|
| default | 200 (PDP rule R-AZ-03) | 404 (PDP rule R-AZ-03) | A valid token is not a permission: the service asked the PDP about this quote. |
| private | 401 (PDP rule R-AZ-01) | 401 (PDP rule R-AZ-01) | Being inside the network adds no identity: the service still needs a credential and a decision on the record. |
| forged | 200, returned to an unauthenticated script (nobody decided) | 200, leaked (nobody decided) | A plain x-app-id header is metadata, not proof: the service that trusted it returned the quote. |
| forged_mtls | 401 (svc-quote) | 401 (svc-quote) | Requiring the mTLS peer identity refuses the forged header: identity comes from a verified credential. |
Case UW-A04 is the forged row, and it is the performance proposal carried out. The same request_path function, run in a scratch copy with forged_app_id and trust_header on:
== forged trusted {'status': 200, 'data_returned': True, 'leaked': True}
1 caller | header x-app-id: svc-cockpit-bff; no token; no client certificate | unknown | sends | nobody | a header any program can type
2 gateway | none | unknown | bypassed | nobody | the script calls the service's internal address directly
3 service | x-app-id header (claimed: svc-cockpit-bff) | svc-cockpit-bff (claimed, never verified) | trusted the header | nobody | the service treats the header as an internal caller and skips the PDP
4 database | service account of svc-quote | svc-quote | rows: 1 | nobody | SELECT * FROM quotes WHERE quote_id = 'Q-5531' (id only)
lesson: A plain x-app-id header is metadata, not proof: the service that trusted it returned the quote to an unauthenticated script.
And with trust_header off, so the quote service requires the mTLS peer identity issued by the internal CA:
== forged mtls {'status': 401, 'data_returned': False, 'leaked': False}
1 caller | header x-app-id: svc-cockpit-bff; no token; no client certificate | unknown | sends | nobody | a header any program can type
2 gateway | none | unknown | bypassed | nobody | the script calls the service's internal address directly
3 service | no verified peer identity (mTLS required) | unknown | deny 401 | svc-quote | the service requires the mTLS peer identity (a SPIFFE id from a verified certificate); the header proves nothing
4 database | none | none | not reached | nobody | no query
lesson: Requiring the mTLS peer identity refuses the forged header: identity comes from a verified credential.
The internal CA and the service's demand for a verified peer identity carried the second run. The network did nothing in either run; the script was inside it both times. The agent here is a scripted stand-in, so these results show how the access controls work, not how good any model is.
Common confusion. The internal CA authenticates the peer. It does not authorize the request. Once mTLS has proven the caller issvc-cockpit-bff, the quote service still asks the policy decision point whether that caller, acting for that person, may do that action to that record. Workload identity owns caller allowlists and thex-app-idlesson.
Provider access through your own cloud account, or a public API from a laptop#
The same model can be reached in two ways that differ in path and account, not in the model. From a laptop, a developer calls a public model API with a personal key across the internet; what is sent falls under that account's terms, and the organization may never know. From the private environment, the LLM gateway calls a model service inside the organization's own cloud account, through a private endpoint, with the gateway's cloud identity. Product (Claude API, as documented on 2026-11-18): on cloud platforms, "authentication is integrated with the cloud provider's IAM system"; the documentation lists Anthropic-operated offerings (Claude Platform on AWS, Claude Models on Google Cloud, Microsoft Foundry) and partner-operated ones (Amazon Bedrock, Claude Models on Google Cloud managed by Google). The organization's own cloud policies then decide who may invoke which model. Product (Amazon Bedrock, as documented on 2026-11-18): a model invocation "is authorized like any other bedrock:InvokeModel request, against the policies that apply to the principal making it", and the condition key aws:SourceIp is absent for requests through VPC endpoints, so a policy written around source addresses behaves differently on the private path.
| Question | Public API from a laptop | Own cloud account from the private environment |
|---|---|---|
| Network path | Public internet | Private endpoint; egress allowlist |
| Credential | Personal API key | Gateway's cloud identity (no stored key) |
| Who is identified | The developer's account | The gateway workload, plus the calling application if the gateway records it |
| Who decides which models | The account's settings | The organization's cloud policies |
| Who sees the call | The developer and the provider | The organization's audit, the gateway's logs, the provider |
| Residual risk | Key leaks; data under personal terms; no organizational record | Prompt logs at the gateway; endpoint policy left at full access; over-broad model permissions |
The right column moves the risk into places the organization controls and audits. The left column is fine for prototyping with synthetic data, and wrong for a real submission.
What this is not. This page does not teach cloud IAM, federation or secrets managers: Cloud IAM does. The four ways to authenticate a model call are compared on Model providers; gateways, WAFs and meshes on Gateways and zero trust.
Failure mode: "inside means trusted"#
Follow the performance proposal through, as a labelled mistake. The quote service accepts internal callers without a token. Months later a reporting tool in the same network is compromised through an unpatched library. The attacker, now running code inside, finds that the quote service answers anything that reaches it, and every quote of every brokerage is readable. The audit log shows requests with no principal, because none was ever established. No network control broke; the missing check was in the one place that could make it.
The correct state is the one the example implements: the quote service requires a verified peer identity (mTLS from the internal CA) for workloads and a validated token for the person; it asks the policy decision point on every record; and the repository applies the tenant or unit predicate from the verified context. The private network then becomes one more layer that shrinks who could ever try.
In a coding agent. A build runner inside the private network is a workload like any other. Its network position must not give it database access: a coding agent's sandbox gets no production database credential, and the CI job that deploys reaches the cloud through OIDC federation with a role scoped to deployment. Coding agents owns this case.
Architecture choice: how much private environment do you need?#
Private networking is useful and costs real effort to run. The simplest credible design depends on what the data is and who must be able to prove where it went.
| Situation | Simplest credible option | Grow when | Alternatives |
|---|---|---|---|
| A small SaaS product with public users | Public endpoints behind a managed gateway; strong authentication and object checks in every service | Customers or regulators require private connectivity | Private endpoints for the data stores only |
| Internal services with sensitive data | Private network plus workload identity (mTLS or signed tokens) and per-service authorization | Many teams, shared platforms | Service mesh with mTLS everywhere |
| Regulated data and model calls | Private controlled environment: private endpoints with restrictive policies, egress allowlist, LLM gateway in the organization's cloud account, admin audit, change management | Several regions or residency rules | Separate environments per jurisdiction |
| Prototype with synthetic data | Developer laptop, public API, a key with an expiry | Any real customer record appears | A sandbox account in the organization's cloud |
This site's recommendation: build the private environment for what it does well (fewer doors, controlled exits, organization-owned accounts, auditable paths), and keep every service's authorization as if the network were hostile. Write each control's residual risk next to it in the design document, so it gets an owner.
Standards and products for this chapter#
Guideline (NIST SP 800-207, Zero Trust Architecture, August 2020, read 2026-11-18): the private network is not an implicit trust zone; access is granted per session, by dynamic policy, after authentication and authorization. Standard (RFC 5280 for X.509 certificates and RFC 9846 for TLS 1.3, read 2026-11-18): the basis of an internal CA and of mutual TLS. Product (as documented on 2026-11-18): AWS PrivateLink endpoint policies, Amazon Bedrock model access, Claude API overview, Let's Encrypt on ending TLS client authentication. Pattern: egress allowlists, the LLM gateway, the internal API gateway, change advisory review. Equivalent private-endpoint features of other clouds were not read for this page; check their documentation before relying on a default.
Security notes#
Security note. Attach a restrictive endpoint policy to every private endpoint that supports one: name the principals and the resources (your accounts, your buckets, your models). The default policy allows full access.
Security note. Treat the internal CA's issuance policy as access control. Who may request a certificate for svc-cockpit-bff, and how that request is approved, decides who can become the cockpit.
Production pitfall. An egress allowlist that names a whole cloud service ("allow the storage service") allows uploads to any account at that service. Combine destination allowlists with endpoint policies or a forward proxy that checks the account or bucket.
Security note. The LLM gateway's prompt logs hold whatever the agent sent: submission details, retrieved passages, possibly regulated data. Classify that store like the data it contains.
Monday checklist#
- List every service that accepts a request without a validated credential "because it is internal". Give each one a workload identity check and a policy decision.
- For each private endpoint, read its endpoint policy. Replace full-access defaults with named principals and resources.
- Read the egress allowlist and mark each destination that accepts data from any account. Decide how each is restricted.
- Write down who can request certificates from the internal CA and for which names.
- Check that every model call leaves through the LLM gateway, and that no application holds a provider key.
- For each control in your design document, add one line of residual risk and an owner.
Exercises#
- The network team proposes removing mTLS between internal services because "the VPC already isolates them". What do you answer, in one sentence?
AnswerIsolation from outside is not identity inside
The VPC keeps the internet out; mTLS tells the quote service which inside workload is calling, which the policy decision needs, and UW-A04 shows what happens when a service trusts its network position instead.
- A private endpoint to the cloud storage service is in place with its default policy, and the egress firewall blocks the public storage address. Can a compromised workload copy quotes to a storage bucket in an account the insurer does not own?
AnswerPossibly yes, through the endpoint
The default endpoint policy grants full access, so unless an endpoint policy or bucket policy restricts the accounts and resources, the private path can reach other accounts' buckets. Restrict the endpoint policy to the organization's own resources.
- The enterprise IdP is the only sign-in for underwriters. Does that settle whether
u-uw-w2may decideSUB-1004?
AnswerNo; the IdP says who, the policy says what
The IdP authenticates the peer underwriter. The policy decision point refuses the decision because u-uw-w2 is not assigned to SUB-1004 (case UW-A09, rule R-AZ-09).
Advanced perspective#
Exfiltration through approved destinationsThe allowlist checks the host, not the account
Egress control answers "may this workload connect to this host?". Data loss usually happens through hosts that are on the list: a cloud storage service, a code hosting site, a model provider, a messaging platform. All of them accept data from any account that authenticates.
The controls that close this gap work at the account or resource level. For cloud services reached through private endpoints, an endpoint policy can name the principals and resources allowed (AWS documents that endpoint policies use the IAM policy language and must contain a Principal element). Bucket or resource policies can require that access comes from a specific endpoint or network. For SaaS services, a forward proxy that inspects the tenant or organization identifier in the request is a common pattern, with its own cost: it needs TLS interception, which brings a certificate the proxy controls into every client's trust store, and that certificate becomes another crown jewel.
For model providers, the LLM gateway is the natural choke point: if it is the only workload with a route to any provider, and it holds the only credential, then a personal key on a laptop inside the network has nowhere to go. That property depends on the egress allowlist naming the gateway's provider endpoint for the gateway alone, not for the whole network.
Running an internal CA without making it the weakest linkIssuance policy, short lifetimes, and offline roots
An internal CA concentrates trust. Its root key must be protected far more than any service key, usually offline, with intermediates doing day-to-day issuance. The issuance policy (who may obtain which names) is the real authorization layer for workload identity, and it should be automated against an inventory: a workload gets a certificate for its own name because the platform knows what it is, not because someone filed a ticket.
Short lifetimes reduce what revocation must do. Public CAs show the direction: Let's Encrypt turned off its OCSP service in 2025 and publishes revocation only through CRLs, and its short-lived profile issues certificates valid for 160 hours (as documented on 2026-11-18). An internal CA can go further, with workload certificates that live hours and renew automatically, as SPIFFE implementations do (see Workload identity). The residual risk moves from revocation to renewal: if renewal fails, services stop talking to each other, so renewal needs monitoring and a tested recovery path (Operations).
Finally, the trust store itself is configuration. A workload that trusts the internal CA and also every public CA can be reached by a public certificate for an internal-looking name, unless hostnames and SANs are checked against the internal namespace. Decide per client which CAs it trusts.
Change management for network, policy and identityThe same review for a firewall rule and an authorization rule
Private environments are usually defined as code: network rules, endpoint policies, CA issuance rules, IdP group mappings, authorization policy. That makes them reviewable in the same way as application code: a pull request, a reviewer who is not the author, an automated check, a recorded release. The authorization policy in this example has two versions, authz-2026.10.3 and authz-2026.11.1, and the older one lacks the assignment check on decision.record; that is the kind of difference change review exists to catch (Policy as code).
Emergency changes are where the process breaks. A good design gives emergencies their own path rather than an exception to the normal one: a break-glass role with a short time limit, an alert to a second person, and a mandatory review afterwards (Privileged access, case UW-A19). A firewall rule opened in an incident should carry an expiry in the same change, so that closing it does not depend on someone remembering.
The residual risk is the reviewer. A reviewer who approves a 400-line network diff they cannot evaluate adds a signature, not a control. Small changes, generated summaries of effective access ("this change lets subnet X reach service Y"), and automated policy tests make review possible.
Developers inside a private environmentAccess for people without turning laptops into trusted workloads
People need to reach a private environment: to debug, to read logs, to run a migration. The old answer was a VPN that put the laptop on the internal network, which made the laptop an inside workload with network reach to everything. The zero trust answer is an access proxy per application: the person authenticates at the enterprise IdP, the proxy checks identity and device posture, and the person reaches one application, not a network. NIST SP 800-207 describes a policy enforcement point that may be split into a client-side part (an agent on the laptop) and a resource-side part (a gateway in front of the resource), which is this design.
For administrative access, the person gets no standing rights; they request just-in-time elevation with a time limit and an approval, and every session produces admin audit (Privileged access, case UW-A18). For data access, regulated data is read through applications that enforce record-level policy, never through a direct database client on a laptop.
In one breath#
A private controlled environment decides who can reach each service and which outside endpoints any workload may call, and it moves model access into the organization's own cloud account. Each of its controls protects something real and leaves a residual risk: a private endpoint with full access by default, an allowlist that cannot see accounts, a CA whose issuance is an access decision, a gateway whose logs hold prompts. None of them decides whether a caller may read quote Q-5531; that decision stays in the service, on the record, for every caller inside or outside.
The underwriting platform now has controlled exits and one LLM gateway that alone may reach a model provider. What that gateway authenticates with, who pays for each call, who sees the prompts and who enforces budgets are still open questions, and the answers differ sharply between a personal key, a service credential, the gateway and cloud IAM. Model providers compares the four.