Many vulnerability management programmes were designed for a world of fixed servers, stable applications and quarterly change. That world has largely gone. Systems are created and destroyed in minutes, applications are assembled from hundreds of third-party components, and infrastructure is described in code that changes daily. A programme built around the assumptions of the past will miss much of what matters today. Building for the future does not mean predicting it. It means designing for change, so that the programme can absorb new kinds of asset without being rebuilt.
Design around the estate you are moving towards
Start with the direction of travel. If workloads are moving to containers, managed platforms or serverless services, the inventory and scanning approach must account for those forms as well as traditional hosts. If engineering teams deploy many times a day, a monthly review of findings will always lag behind the estate. Plan for the platforms you expect to run in the next few years, and check the programme against them.
The design question is not whether the current tools can scan everything today. It is whether the operating model can accept new asset types as they arrive, without a long project each time.
Bring checks into the build pipeline
Where software is built and deployed through automated pipelines, weaknesses are cheapest to address before the software reaches production. Dependency checks, container image assessments and configuration validation can run as part of the build, giving developers feedback while the code is still in their hands.
Pipeline checks need careful tuning. Blocking every build for every finding will quickly create resentment and workarounds. A better approach is to set clear thresholds for blocking, report lower-priority items for triage, and track the proportion of findings that originate in code rather than in production configuration.
Manage the software supply chain
Modern applications depend on libraries, base images and build tools supplied by others. A weakness in a widely used component can affect many products at once. Future-ready programmes therefore need visibility of components as well as hosts. Maintaining an inventory of software components, often described as a software bill of materials, allows the organisation to determine quickly which products are affected when a new weakness is disclosed.
The practical value of that inventory depends on its accuracy. Generated inventories should be checked against what is actually deployed, and gaps should be treated as a finding in their own right.
Treat infrastructure as code as an asset
When infrastructure is defined in templates, a misconfiguration can be repeated across hundreds of resources in a single change. Templates should therefore be reviewed and scanned before deployment, and the drift between declared and actual configuration should be monitored. A vulnerability management programme that scans only running resources will miss the defect in the template that created them.
Ownership of templates needs to be explicit. Platform teams often maintain the shared modules, while product teams adapt them. Both groups should understand their share of the risk.
Plan for identity and access
As estates become more distributed, identity becomes one of the main boundaries of control. Weak credentials, overly broad permissions and unused service accounts can expose systems that appear well maintained. Future-ready programmes include identity configuration in their assessment scope, and they treat privileged and automated accounts as assets with owners and review dates.
Keep the human process in view
Automation changes the workload but not the need for judgement. Someone must decide which findings represent real exposure, which owners need support and when a risk is acceptable. The programme should define those roles in advance, and it should measure whether the people in them have the time and skills to perform them well.
Future readiness also depends on learning. Review recurring findings to identify root causes, share lessons across teams and adjust the platform standards where the same problem keeps appearing.
Avoid designing for a single tool
Tools change, and the organisation that built its process around one product may struggle to change course. Define the programme's requirements in terms of capabilities and outcomes, such as complete inventory, validated findings, owned remediation and verified closure. Then assess whichever tools are in use against those requirements, and replace components when they no longer serve the outcomes.
Designing for short-lived resources
Some of the most important assets in a modern estate exist for minutes or hours. Auto-scaling groups add capacity during demand, test environments are created for a single release and containers are replaced whenever a new image is deployed. A programme that discovers assets once a month will never see most of them. Future-ready designs therefore treat discovery as a continuous stream, fed by the platforms themselves rather than by periodic network sweeps.
Tagging is the practical foundation. Every resource should carry an owner, an environment and a business purpose, applied automatically at creation. Where tags are missing, the resource should be flagged for review rather than silently accepted. Without tags, a weakness found on a short-lived resource may have no owner by the time the finding is raised, and the work drifts to a central team that lacks the context to fix it.
Decommissioning matters as much as creation. Resources meant to be temporary often persist, and they keep their exposure long after the project has ended. Build decommissioning steps into the lifecycle of each platform, and review resources that show no recent activity or have no owner. A regular clean-up of forgotten assets is a modest step that removes a meaningful part of the exposure a programme would otherwise have to manage.
Teams building these platforms should be involved early. Retrofitting tagging and discovery into a platform already in service is slower and more contentious than designing them in from the start.
Common mistakes
- Designing the programme around the estate of five years ago.
- Blocking pipelines for every finding and encouraging teams to bypass the controls.
- Treating software components as invisible until a disclosure forces the question.
- Scanning running resources without checking the templates that created them.
- Locking the process to a single tool that cannot adapt to new asset types.
Next steps
Map your estate's expected platform changes over the next planning horizon, including the 2027 budget cycle, and identify the asset types the current programme cannot see. Prioritise pipeline integration and component inventory for the teams that deploy most frequently, and review the operating model once those are in place.
Frequently asked questions
Do we need to scan containers and infrastructure templates separately?
Yes, in most cases. Images, templates and running resources each carry different weaknesses, and each should be checked at the point where it is most useful.
Is a software bill of materials mandatory?
That depends on the contracts, regulations and customers that apply to your organisation. Confirm the obligations with your legal and compliance advisers. The value of an inventory exists regardless of whether it is required.
How do we stop pipeline checks slowing developers down?
Agree thresholds for blocking with the teams involved, report lower-priority findings for triage rather than blocking, and review the rules regularly against the findings they produce.
Related reading
If you are working through this topic, these related articles cover neighbouring questions:
