Disabling install scripts fleet-wide breaks a third of your builds - is that switch a control?
answer
- concede the reduction first
- capability removed, trust not decided
- configured in places, not enforced anywhere
- exceptions select the native-build packages
- owner, enforcement point, exceptions, evidence
basics
~20 sOn its own, no. The flag removes one execution point without deciding which packages you trust, and it holds only where someone set it. Import-time code still runs. A control has an owner, an enforcement point, an exception path and evidence.
solid answer
~50 sIt is a real risk reduction and a poor control, and a platform lead should be able to say both. It reduces risk because it removes an unconditional execution point from every build. It is not yet a control because it decides nothing about trust, it is enforced only where the configuration happens to be set - CI but not laptops, one ecosystem but not the next - and it produces breakage that gets resolved by ad-hoc opt-outs no one records. The breakage itself is the interesting signal: the packages that fail are largely the ones compiling native code at install, which are precisely the highest-capability ones, so 'just add exceptions' quietly re-admits the worst cases. Turn it into a control by making default-deny the platform's configuration rather than the repo's, keeping a reviewed allow-list of packages permitted to run install code with a named owner and an expiry per entry, and stating the residual plainly: build-time and import-time execution remain.
go deeper
Know that turning off install scripts stops one kind of execution and that some packages genuinely need it to build, so builds can fail when you do it.
Explain what still executes afterwards - build-time and import-time code - and why a setting held in each repository is not the same as a setting the platform enforces.
Show how you would handle the breakage: identify which packages actually need install-time execution, give each an owner and an expiry, and keep the residual risk written down.
Own the distinction between a mitigation and an auditable control, argue the adverse selection in the exception list, and be ready to defend the rollout sequence and the friction it imposes on the whole estate.
## The question behind the question An interviewer asking this is not testing whether you know the flag exists. They are testing whether you can distinguish a **mitigation you switched on** from a **control you can be audited against**, and whether you can hold that line in a room where a third of the engineering org has a broken build and wants an exception by lunchtime. ## Why the switch is genuinely worth having Start by conceding the real part. Disabling install-time scripts removes an execution point that is unconditional, early, and available to every package in the resolved tree including the ones nobody chose. That is the cheapest single reduction available in this area, and on a build host it removes execution from the machine most likely to hold deployment or publishing credentials. A candidate who dismisses it looks contrarian rather than senior. ## Why it is not yet a control Four reasons, in the order they matter: **1. It answers the wrong question.** It removes a capability; it does not decide which publishers you are willing to run. The package still installs, still ships whatever code it shipped, and still executes when the build or the application touches it. Trust was never evaluated. **2. It is not enforced, only configured.** A flag that lives in a repository's configuration is advisory: a new repository omits it, a developer's laptop never had it, a container build invokes the installer differently, and another ecosystem in the same monorepo has its own unrelated behaviour. Controls have one enforcement point that a team cannot silently opt out of. **3. Its exceptions are adversely selected.** The builds that break are dominated by packages that compile native extensions or generate code at install - which is to say, packages with the largest install-time capability and the most opaque payload. Left to per-team triage, the exception list converges on exactly the population you were most worried about, and nobody ever sees the list as a whole. **4. It leaves no evidence.** You cannot show an auditor, a customer or your own incident review which repositories are covered, which are exempt, who approved each exemption and when it was last revisited. A control produces that record as a by-product. ## Turning it into one The shape of the answer is standard control design applied here: - **Default-deny at a place teams do not own.** The install configuration comes from the platform's build image or shared configuration, not from each repository, so the safe setting is inherited rather than remembered. - **An explicit allow-list of packages permitted to run install code**, each entry carrying a reason class - native compilation, code generation, vendored binary - a named owner, and an expiry that forces a re-look rather than permanent grandfathering. - **A path off the list.** For most entries there is a way out: consume a pre-built artifact, vendor the built output, or move the compilation into a controlled build of your own. Making the exception uncomfortable and time-boxed is what stops the list from growing forever. - **Measurement that is about exceptions, not about the flag.** 'The flag is on in 98% of repos' is a vanity metric. 'The number of packages permitted to run install code fell from 140 to 30, and every remaining one has an owner' is a control improving. - **A written residual.** Say out loud that build-time and import-time execution are untouched, so that nobody in the organisation concludes that dependency risk has been handled. This is the sentence that keeps the next incident from being a surprise. ## The conversation with the teams The political failure mode is to announce the change, break a third of the builds, and let each team negotiate its own escape. That produces the worst of both outcomes: real friction and no control. Sequence it instead - measure first which repositories actually depend on install-time execution, because it is usually a minority and knowing the number changes the conversation; land the default where it is enforced and where breakage is visible and fixable; publish the allow-list so exceptions are a shared object rather than a private workaround; and only then move to developer machines, where enforcement is weakest and where the flag is most often assumed to be in effect when it is not. ## The one-line version A workaround is something you turned on. A control is something you can prove is on, know the exceptions to, and can say what it does not cover. This switch is worth having, and it becomes a control only when it acquires an owner, an enforcement point, a reviewed exception list and a stated residual.
- How do you stop the allow-list of script-permitted packages from becoming a rubber stamp?Give every entry a named owner, a reason class and an expiry, so silence removes an entry instead of preserving it. Require the requester to say why the alternative - a pre-built artifact, vendored output, or your own controlled build - does not work. Then track the list's size as the metric, since a control that is working shrinks.
- A team says the flag makes them safe. What do you tell them?That it removed one execution point, not the dependency's ability to run code. The module still executes when something imports it, the build tool can still run package-supplied code, and the flag is almost certainly not in effect on their laptops or in their container builds. Safe is the wrong word; narrower is the right one.
- How would you sequence this across four hundred repositories?Measure first: find how many repositories actually resolve packages that execute at install, because the number is usually small and it reframes the whole debate. Then set the default in the platform-owned build configuration, where breakage surfaces immediately and can be fixed centrally, publish the exception list, and move to developer environments last.
saying these in an interview costs you the question
- Claims disabling install scripts removes dependency risk
- Treats a per-repository opt-out as real enforcement
- Grants blanket exceptions with no owner or expiry
- Assumes the setting also applies on developer laptops
- Measures success by flag coverage rather than shrinking exceptions
- Refuses the change outright because builds would break