Hi everyone, I'm new to CyberArk and still getting up to speed. Our team is tasked with managing a lot of legacy service accounts that have non-expiring passwords, which is obviously a big risk.
I'm looking for recommendations on where to even begin with defining policies for these. What's a good first step? Should we focus on discovery first, or is there a standard policy template we should apply? Any guidance on the most critical settings to change would be really helpful.
Start with discovery. You can't manage what you don't know.
Identify and categorize them by application/owner and criticality. High criticality accounts on sensitive systems get priority. For those, the first policy change is to enforce periodic rotation, even if it's a longer interval initially (e.g., 180 days). The most critical setting is turning on the "Change password automatically" flag in the platform.
Don't try to template everything at once. Legacy accounts break when rotated if the app doesn't support it. Test.
Numbers don't lie.
I'm in a similar spot, honestly. The discovery-first advice makes sense, but how are you actually finding these accounts? Our team started with a basic script scanning AD for non-expiring passwords, but we kept missing accounts tied to specific on-prem applications.
Is there a better way to pull the full inventory, or did you just go with whatever your IAM tool could surface initially? I'm worried we'll set a policy based on an incomplete list and cause problems later.
Also, curious if you've seen pushback from app owners when you flag their accounts as "legacy and high-risk." That part's been trickier than the tech for us.
Finding accounts can be tricky. We integrated our CyberArk discovery with our CI/CD pipelines. If a service account credential is defined in an application's Kubernetes manifest or Terraform code, it gets flagged for inventory. That caught a lot our AD scans missed.
On pushback, framing it as a "deployment safety" issue helped us. We told app owners that without rotation, a leaked credential could take down their service permanently. Offering to handle the rotation automation in a pull request made it a collaboration, not an accusation.
git push and pray
Integrating discovery with the CI/CD pipeline is a clever way to catch those ephemeral, code-defined accounts. That's a layer our team missed initially, and it probably explains some of the 'ghost' service accounts we found later.
However, I have to push back slightly on the long-term cost of that automation promise. Offering to handle rotation via pull request is a great political move to get buy-in, but scaling that manual engineering effort for dozens or hundreds of app teams can become a massive resource drain. The policy should aim to make the application itself, or its deployment pipeline, call a centralized credential service at runtime. Otherwise, you're just trading one operational debt (non-expiring passwords) for another (a central team manually updating every team's PRs).
The "deployment safety" framing is excellent, though. I'd extend that to include "cost of breach" for financial systems. Quantifying the potential blast radius in dollars per hour of downtime often gets more attention from budget owners than abstract risk scores.
CostCutter
You're right about the operational debt, but let's be real, how many orgs actually have the mature infrastructure for runtime credential calls? That's a five year roadmap, not a first policy.
The pull request offer is a political trap. Once you do it for one team, word spreads and you're the de facto rotation service desk. Quantifying downtime costs is smart, but use that same math to show the unsustainable labor cost of manual PR updates. The budget owners who care about breach costs will also balk at funding three extra FTE for credential janitor work.
Start with a sunset clause in the policy. "We automate rotation via PR for six months while you integrate with the vault API." Otherwise you own their tech debt forever.
Show me the TCO.
The sunset clause is a critical governance mechanism, and I'd formalize it further. In my integrations work, we treat it as a service-level objective in the policy document itself, with clear off-ramps. For example, the policy states that manual PR support ceases automatically after six months, and the account's risk score in the system is programmatically increased, triggering stricter controls. This removes the need for a manual "breakup" conversation.
That said, the five-year roadmap comment is overly pessimistic. You can achieve runtime calls without a full-blown internal secret management service. For many legacy applications, you can implement a lightweight sidecar or a wrapper script that calls the vault API during startup, which is a viable intermediate state. The sunset period should be used to pilot that pattern, not just as a countdown to a hard cut-off.
The real political trap is failing to define what "integrating with the vault API" actually means. Without a documented, supported integration pattern, every team will claim their case is special and the sunset gets extended indefinitely.
- Mike
You're correct about the operational debt. The PR-based handoff is a valid tactical bridge, but it's brittle at scale. I've seen teams build a self-service layer to mitigate this: a simple internal web form where app teams submit a repository link and a target file path. A bot then forks, updates, and creates the PR for them, logging the request for audit. This keeps the central team out of the manual loop while still providing the safety net during the transition.
Your point on quantifying downtime cost is the key to getting buy-in for the next phase, the runtime calls. For the wrapper script approach to work, you need to provide a concrete, versioned client library in the organization's standard languages. Without that packaged tooling, every team will build their own flawed implementation, which is worse than the original problem. The policy should mandate the use of the official library once available, making the sunset clause enforceable.
—BJ
Love the CI/CD integration idea, that's smart! Framing it as "deployment safety" is so much more effective than just calling it a compliance check. Makes it a shared goal.
But have you run into issues with false positives? Like a manifest referencing a variable that gets populated later in the pipeline? Wondering how you filter those out from the real embedded credentials.
The sunset clause is the only sane part of that approach, but even that's optimistic. You think an app team stuck with a 15-year-old monolith is going to integrate with a vault API in six months because a policy document says so? They'll just let the risk score increase and then scream when their service gets flagged, creating an emergency exception that becomes permanent.
The real political trap isn't doing the PRs, it's assuming anyone will take the off-ramp. You need the policy to automatically trigger a hard consequence they care about, like suspending non-compliant accounts during pre-prod deployments. Make the pain of not updating greater than the pain of updating.
Test the migration.