Case Study: An Access-Scope Escalation That Became a Guardrail
This is a real pattern, not a hypothetical: a routine review of a working integration turned up a script with far more access than it actually used. It was not a security breach, and nobody had done anything wrong on purpose — which is exactly what made it worth writing up.
The problem
A script that only ever read one type of resource had been granted broad read-write access across several resource types. Nothing had gone wrong because of it yet — the risk was purely that if the script or its credentials were ever compromised, the blast radius was far larger than the task required.
The cause
Requesting broad access is the path of least resistance under deadline pressure — it avoids a second round-trip to ask for more scope later if the task grows. Nobody chose this deliberately; it was just the easier request to make at the time, and nothing ever came back to narrow it afterward.
The fix
Narrowing that one script's permissions was the small fix. The real fix was adding a short checklist step before any integration ships: list exactly what access the code actually uses, not what it was granted, and request only that. A one-off correction became a standing habit, which is the difference between fixing an incident and preventing the next ten.