I joined this week. Only one person could deploy to France. That is not a deployment process.

I walked into a platform this week. There were Ansible playbooks for everything. There were no CI validation steps. There were no automated promotions between environments. To deploy the front-end project to France, the team needed one specific engineer. He was the only person with the credentials and tribal knowledge required to run the deployment.

He was on annual leave for two weeks. Production needed a hotfix. The team waited.

This pattern is everywhere. Companies that grew up on shell scripts, Ansible, or hand-rolled deployment tooling rarely notice that their deployment pipeline has a truck factor of one. The playbooks work. Deployments succeed. Production stays up. The fact that only one human in the company can actually run them does not surface until that person is away or leaves.

The risk is silent because the system appears to function. Until it does not.

Three questions to ask your platform team this week.

• If your most senior platform engineer disappeared tomorrow, can production still be deployed to every region?
• Are deployment credentials, runner access, and environment-specific configuration documented anywhere outside that engineer's terminal history?
• How many environments are gated by a single named human in a chat thread or an approval ticket they alone can action?

If the answers are no, no, and several, you have the same failure mode I walked into. The fix is not more documentation. The fix is making the deployment self-service for everyone on the team, with the right gates.

Here is what I shipped in a week. I set up GitHub Actions self-hosted runners inside the private VPC, so the runners had network access to the internal systems without exposing them. I wrote a GitHub workflow that wrapped the Ansible playbooks, made the environment selection an input, and required environment-specific approval gates for production. Every engineer on the team can now trigger a deployment to any region. Production requires two named approvers from a defined group. The single-person dependency is gone.

The Ansible playbooks did not change. The tools did not change. The control surface changed. That is what most platforms in this situation need. Not a rewrite. A control plane that turns single-person tribal knowledge into a gated, audited, self-service workflow that any team member can run.

• Self-hosted runners inside the private network where the legacy systems live
• GitHub workflow as the single entry point, with environment as an input
• Approval gates per environment, scoped to a named group not a named person
• Audit logs the team can read without asking the platform engineer
• Same playbooks underneath. No infrastructure rewrite.