An application team wants a connection-scoped grant on its busiest internal service to protect p99: how do you weigh that against the open pipe?
answer
- Measure before you argue
- Which shape produced the number?
- Volume lives on read paths
- Cheapen the rule, keep the unit
- Write the consequence in their words
basics
~20 sMeasure the real added latency and where it comes from, then decide per endpoint rather than per service. Concede on high-volume read paths, and state plainly what one open pipe lets a compromised device do on that service.
solid answer
~50 sDo not argue security against latency in the abstract; make both sides concrete. First measure: a parse plus a small local policy evaluation at a connector beside the workload is a very different number from a network round trip to a remote decision service on every call, and teams usually quote the second while you could build the first. Second, split the service: the read paths that generate most of the traffic can carry a broad per-request allow, which is cheap to evaluate and still produces a decision record, while the handful of state-changing and administrative paths keep real rules. Third, be honest about where you have no leverage: protocols the connector cannot parse are already all-or-nothing, so nothing is being conceded there. Where you do concede, write down the consequence — any process on an authorised device that reaches the local tunnel endpoint gets everything that account can do on the service, and the service's own log becomes the only record.
go deeper
Know that per-request decisions add work on the request path, and that the alternative is a grant covering everything inside one session.
Explain which implementation shapes make per-request decisions expensive, and why a broad per-request allow still differs from a connection-scoped grant.
Demonstrate the negotiation: measure the real cost, split the service by endpoint, exempt the paths that cannot be parsed, and state the consequence of every concession.
Own the position that grant scope is decided per path with the owning team, and that a control removed after a latency incident protects nothing.
## Turn a slogan fight into two measurements The request as stated — "give us a connection-scoped grant, per-request checking costs us p99" — is usually made before anyone measured. Two numbers settle most of the argument. **Where does the cost come from?** Per-request enforcement has several possible shapes with wildly different costs: | Shape | Typical cost per request | |---|---| | Parse plus in-process evaluation of a small policy at a connector next to the workload | Sub-millisecond to low milliseconds | | Parse, then a network call to a remote decision service, per request | A full round trip, plus its failure modes | | Re-establishing a session or re-authenticating per request | Far worse, and usually a design error | If the team is quoting the second or third and you can deliver the first, the disagreement is about implementation, not about the unit of decision. **What is actually behind the endpoint?** "The busiest internal service" is not one thing. Ninety-plus percent of the volume is usually a small number of read paths. The dangerous surface is a handful of state-changing and administrative operations that carry almost no traffic. The trade you are being offered is stated at service granularity; the answer is at endpoint granularity. ## The shape of a defensible compromise - **Keep the unit of decision, cheapen the decision.** A per-request grant does not require a complicated rule. A broad allow for a path prefix is trivial to evaluate and still yields a decision record naming identity, device and resource for every call. You keep attribution and bounded scope while paying almost nothing for the high-volume paths. - **Spend the real rules where the volume is not.** Administrative and write paths get specific policy. They are rare, so their cost is invisible in the aggregate. - **Concede where there is nothing to concede.** Protocols the connector cannot parse are already all-or-nothing. Saying so builds credibility, and it moves that conversation to where it belongs: the target system's own accounts, permissions and audit trail. - **Refuse the blanket version.** A connection-scoped grant covering the administrative surface as well as the read paths is the version to push back on, because that is where an implant on an authorised device converts one session into every action the account can perform. ## What you owe the team in return Be explicit about the failure posture you are introducing, because it is the team's outage as much as yours. A decision on every request is a dependency on every request: if the policy path is unavailable, does the connector fail closed and take the service down, or fail open and stop being a control? That choice belongs in the same conversation as the latency number, and it is the one an application team will remember. Also be explicit about the maintenance burden you are asking them to carry. Per-request rules track the application's own surface. When they add a path, a stale rule denies real users. If nobody on their side will own that, a per-request grant degrades into a broad allow anyway — better to plan for the broad allow deliberately than to discover it during an incident. ## Say the consequence in one sentence When you do grant connection scope, put the consequence in writing in language the team will recognise: *"Any process running on an authorised laptop that can reach the local tunnel endpoint gets everything this account can do on your service, for as long as the session is open, and your application's own log is then the only record of what it did."* That sentence does more than any policy document, because it converts an abstract control into a description of their service on a bad day. ## The wrong answers to aim at The first is refusing on principle — insisting on per-request enforcement everywhere, which gets the control removed entirely the first time it appears in an incident review for latency. The second is conceding at service granularity because the team quoted a number, without checking which shape produced it or which endpoints the concession actually covers. Both are common; the difference between them and a good answer is that a good answer arrives with a measurement and an endpoint-level proposal.
- The team says per-request enforcement adds a dependency that could take their service down. Are they right?Yes, and it should be answered rather than deflected. A decision on every request is an availability dependency, so the fail-open versus fail-closed choice becomes a joint decision with a visible cost either way. Keeping evaluation local to the connector removes the remote-call failure mode, which is usually what they are really worried about.
- How do you keep a broad per-request allow from being pointless?It is not pointless if it produces a decision record per request naming identity, device and resource, and if the narrow rules still cover the state-changing and administrative paths. What makes it pointless is a single allow-everything rule with no record, which is a connection-scoped grant wearing a different label.
- Which parts of this service would you refuse to place under a connection-scoped grant at all?The administrative and state-changing surface: anything that alters entitlements, configuration, or bulk-exports data. Those carry a fraction of the traffic, so exempting them costs almost nothing in latency, and they are exactly what a process riding an already-open session would use.
saying these in an interview costs you the question
- Refuses on principle without measuring the added latency
- Accepts the trade at service granularity rather than per endpoint
- Ignores the failure posture the per-request dependency introduces
- Assumes a broad per-request allow is worthless