Software configuration management exists so a team can rebuild any released version and show which approved changes went into it. The discipline controls how code, scripts and documents change over time.
In practice it covers source code and build scripts, plus the requirements and test cases around them. Standards like IEEE 828 and ISO 10007 are what teams measure the practice against.
NIST SP 800-53 Rev. 5 goes further and treats it as a formal control family. That family has separate controls for baseline configuration, configuration change control, impact analyses and a configuration management plan.
What is software configuration management?

It identifies, controls, tracks and audits changes to software artifacts. The point is that every released version can be reproduced and traced to the changes behind it.
The wider practice of configuration management gets applied here to code, scripts and documentation. IEEE’s Technology Navigator notes the same principles cover hardware, software, firmware and any mix of them.
The SWEBOK Guide v4 (2024), from the IEEE Computer Society, gives the discipline a knowledge area of its own.
The IEEE Computer Society warns that without it, a team risks being unable to recreate past builds. Usually that happens because nobody recorded which versions were included. Unauthorized changes can also slip into a release, and a release may not trace back to any requirement, defect or approval.
Brian White’s book on SCM strategies with Rational ClearCase argues software is harder to manage than hardware. Edits are cheap, and physics doesn’t put anything in the way to slow one down.
What are the core activities of software configuration management?

The SWEBOK Guide breaks the work into planning and managing the SCM process, configuration identification, configuration control, status accounting, auditing, and release management and delivery.
Not every source draws the list the same way. University course materials often stop at identification, control, status accounting and auditing, and treat planning and release as surrounding work. ISO 10007:2017 structures its process as planning, identification, change control, status accounting and audit.
It’s the same work in each case. The only real disagreement is where release belongs.
Planning and process management
Everything starts with the configuration management plan. It records who does what, which items are controlled, what tools apply and when audits happen.
Write it early, before the first baseline exists.
Configuration identification
The IEEE glossary (1990) describes identification as selecting the configuration items for a system and recording their functional and physical characteristics. On a real project this ends up as a list of controlled items, each with its own naming and versioning scheme.
Configuration control
Control covers how changes to baselined items get requested, evaluated, approved and implemented. A change request starts it, a change control board decides, and the outcome is recorded as the disposition.
Status accounting
This is the record-keeping side of the job. It lets anyone check the current state of the configuration without digging through repositories: which version of each item sits in each baseline, whether a change request is open, approved, implemented or closed, and what differs between two releases.
Configuration audits
SWEBOK separates audits by what they check.
A functional audit asks whether the item does what its requirements say. The physical audit is about the build itself, checked against its documentation and the approved baseline.
In-process audits happen during development, which means drift from the baseline shows up before any formal review gets a look.
Release management and delivery
Release management builds the deliverable from controlled items, labels the version and hands it over.
Most teams automate the build step with build automation tools, which compile the same inputs the same way every time. A release built by hand from someone’s local checkout is what the whole discipline exists to stop.
What counts as a configuration item, and what is a baseline?
Any work product placed under configuration control and treated as a single unit counts as a configuration item. Group some of those items into a formally approved version that changes only through change control, and you have a baseline.
Configuration items
- Source code
- Build scripts
- Requirements documents and test cases
- Libraries and pinned dependencies
- Environment configuration files
Items go well beyond code. If a release can’t be rebuilt without its build scripts or test suite, it isn’t reproducible, so those belong under control too.
Choosing what goes on the list is a judgment call. Leave too much out and traceability has gaps. Include too many and the team is buried in approvals.
Each item also needs a unique label. Git’s own manual shows one scheme. git describe returns v1.0.4-14-g2414721, which reads as the nearest tag, 14 commits since it, and an abbreviated commit hash.
Release labels commonly follow semantic version numbers (major.minor.patch), so the size of a change shows up at a glance.
Baselines
NIST SP 800-171 Rev. 2 describes a baseline as a documented, formally reviewed and agreed set of specifications that serves as the basis for future builds, releases and changes.
Course materials name several baseline types, and the labels vary by source. Some call the approved-requirements baseline functional, others allocated.
| Baseline | Set when | Contents |
|---|---|---|
| Developmental | During development | Working builds, tested code |
| Functional | Requirements approved | Approved requirements |
| Allocated or design | Design approved | Architecture and design documents |
| Product | Release accepted | Release build and its documentation |
The functional baseline usually freezes an approved software requirements specification. From there on, every edit goes through change control, small fixes included.
How does a change move from request to release?
Say the product baseline is recorded as an annotated Git tag named v1.0. Git’s documentation recommends annotated tags for releases, since they store the tagger’s name, email, date and a message while lightweight tags are plain labels.
A fix for a login timeout defect against that tag goes through these steps.
- Record the request, including the need, the affected items and the requester.
- Analyze the impact by listing the configuration items, tests and schedule the change touches.
- The change control board approves, rejects or defers the request.
- Create a branch from the tag (
git checkout -b fix-timeout v1.0) and make the change there. - Run the tests and review the diff against the baseline.
- Merge the branch, tag the result (
git tag -a v1.0.1 -m "Timeout fix"), and update the status records.
ISO 10007:2017 follows the same order in its change control clause. It starts with initiating and documenting the need, moves to evaluation and disposition, and ends with implementation and verification.
Teams that field a lot of requests tend to formalize intake as change request management, which gives each request an owner and a place in a prioritized queue.
Branching and merging from a baseline
Pro Git describes a branch as a lightweight movable pointer to a commit, so branching from a baseline costs almost nothing. When the approved change returns to the mainline, Git records the merge commit with both parents.
If two branches edited the same item, the result is a merge conflict, and a person has to resolve it before the merge completes.
There’s one failure mode worth knowing about. A tag is only a label, and git tag -f replaces an existing one. So a baseline protected by nothing but its name can be moved, unless the hosting platform restricts tag changes.
Where does version control end and software configuration management begin?
Version control sits inside software configuration management and doesn’t replace it. It records file history. The wider discipline decides which versions form an approved, reproducible release.
| Dimension | Version control | Software configuration management |
|---|---|---|
| Unit tracked | Files and directories | Configurations of many items at a point in time |
| Approval | Optional, tool-dependent | Formal change control with recorded disposition |
| Records | Revision history | Status accounting, audits, baselines |
| Outcome | Recoverable file versions | Reproducible, traceable releases |
Version control

Version control systems such as Git record every change to a file and support branching and merging. They hold the history the wider discipline builds on.
Where people disagree is on how far version control alone gets you. One StickyMinds author argues that it works per file, so it can’t control a whole product by itself. Another StickyMinds article says a team can do configuration management with version control tools alone, given the right process.
Both hold at different scales. A small team with disciplined branching and code review covers most of the work, and a regulated product needs the formal records on top.
Tool documentation muddies things further by expanding SCM as source code management, which means version control alone. A 2010 Mercurial mailing list thread drew that line, noting that the software configuration management meaning also covers change tracking, version numbering policy and build systems.
DevOps and infrastructure as code
Puppet’s materials describe agents that continually check each node against a declared desired state and correct drift. Configuration drift is the gap between declared and actual state, which is an unauthorized change to a baseline by another name.
Keeping that declared state in versioned files is what infrastructure as code means, so servers follow the same change flow as application code.
Puppet is agent-based and enforces desired state, correcting drift as it finds it. Ansible runs playbooks that apply configuration to hosts, and Chef applies configuration written as recipes. Terraform provisions infrastructure from declared configuration files.
Docker images package an environment’s configuration as a versioned artifact, and Kubernetes manifests declare the desired state of a deployment.
The shared name misleads people. A Puppet or Ansible run is configuration management for servers. The discipline covered here governs software artifacts and their releases.
ITIL and change management
ITIL scopes configuration to IT services, not source code.
The ITIL 4 service configuration management practice aims to keep accurate, reliable information about services and their configuration items available when needed, including how items are configured and related (PeopleCert, which acquired ITIL’s original publisher, AXELOS).
Organizational change management and item-level change control share vocabulary (request, approval, baseline) but not scope. Organizational change management approves changes to services; item-level control deals with individual artifacts.
Which tools support software configuration management?
SCM tooling spans version control, build and CI, change tracking and release automation. In a typical Git-based stack, review happens on the hosting platform. Builds run on a CI server, and change requests sit in an issue tracker.
| Tool | Model | Best fit | Main limit |
|---|---|---|---|
| Git (GitHub, GitLab) | Distributed | Source code, text-based items | Large binaries need Git LFS |
| Apache Subversion | Centralized | Directory-level permissions | Commits need the server |
| Perforce P4 (formerly Helix Core) | Central server | Large binary assets | Binaries cannot be merged |
| IBM ClearCase, HCL DevOps Code ClearCase | Server-based | Existing enterprise installs | Narrowing tool support |
Git, GitHub and GitLab
Git keeps the full history in every clone, which suits source code, scripts and other text-based items.
GitHub and GitLab add the review layer. Pull requests and merge requests carry the approval step of the change flow.
Anything over the host’s file limits goes through Git LFS, which keeps pointer files in the repository and the content elsewhere (GitHub Docs).
You get full local history, the largest hosting and CI ecosystem around, and pipeline definitions versioned next to the code. Against that, large binaries need LFS, and the formal approval and audit records depend on whatever the host’s features provide.
Apache Subversion
Subversion fits teams that want one central server and per-directory permissions.
A commit covers any number of files and directories as a single atomic transaction (Subversion book). One revision number covers the whole repository tree, so citing a baseline takes a single integer (CM Crossroads). Read and write access control is path-based.
The cost is that it’s centralized, so commits need a server connection.
Pick it over Git only when directory-level permissions outweigh offline work. That’s a narrow case.
Perforce P4 (formerly Helix Core)
Perforce reported in 2018 that Warhorse Studios replaced a split setup (Subversion for binary files, Mercurial for code) with Helix Core, now named Perforce P4, so large game assets could feed its CI pipeline.
Perforce’s documentation notes that binary files cannot be opened as text or merged in a text-based merge tool. Warhorse relied on strictly enforced file locking instead.
The strength is that one depot holds code and large binary assets, with changelists recording each change. The trade-off is locking. Locks serialize edits to a binary file, so two people can’t work on it in parallel.
IBM ClearCase and HCL DevOps Code ClearCase
ClearCase is the legacy option here.
HCL documents a migration from IBM ClearCase 9.1 to HCL VersionVault 2.0.1. HCL has since renamed VersionVault to HCL DevOps Code ClearCase. Review Board’s documentation calls the VersionVault / ClearCase edition officially supported, while its legacy ClearCase mode is community-driven with limited functionality.
Atlassian ended ClearCase support for Crucible and FishEye on 4 April 2012 and removed the functionality from later releases.
Choose it to maintain an existing deployment. A new project gains nothing from the narrower tool support.
Build, CI and change tracking tools
Jenkins is an open source automation server for building, testing and delivering or deploying software (Jenkins documentation). GitLab CI/CD defines pipelines in a .gitlab-ci.yml file inside each project. Jira keeps issues with a History tab that records field changes, attachments and link changes.
Atlassian’s documentation adds that an issue can show its related commits and builds. That gives auditors a trail from a change request to the code that closed it.
Hooking Jenkins or GitLab CI to every merge is continuous integration in practice, and it is what keeps release builds repeatable.
My default is Git on a hosting platform. Perforce P4 earns its place only when large binary assets drive the repository, and Subversion is worth a look when directory-level permissions dominate.
Which standards define software configuration management?
IEEE 828, ISO 10007, SAE EIA-649C, CMMI and NIST SP 800-128 carry most of the weight, and each frames the same core activities for a different audience.
| Standard | Publisher | Focus | Pick it when |
|---|---|---|---|
| IEEE 828-2012 | IEEE | CM processes and plan contents | You need a plan outline |
| ISO 10007:2017 | ISO | Guidance, concept to disposal | A quality management system applies |
| SAE EIA-649C | SAE | Five CM functions and principles | Aerospace or defense supply chains |
| CMMI V3.0 | ISACA CMMI Institute | Configuration Management practice area | You need an appraised rating |
| NIST SP 800-128 | NIST | Security-focused CM | Federal information systems |
Most are guidance, not law. They bind when a contract, regulator or appraisal cites them, which is when software compliance reviews start asking for baselines and audit records.
The dates are worth checking before you cite any of these.
- IEEE 828 came out in editions of 1983, 1990, 1998, 2005 and 2012, and the 2012 edition has been listed as Inactive-Reserved since 30 March 2023 (IEEE Standards Association).
- ISO 10007:2017 was confirmed on 16 February 2023, then listed as “to be revised” from June 2025, with a working draft, ISO/WD 10007, in development (ISO and national standards bodies).
- SAE EIA-649C was revised on 7 February 2019 and defines five CM functions.
- CMMI V3.0 was released on 6 April 2023 by the CMMI Institute, which no longer accepts V2.0 appraisals.
- NIST SP 800-128 had updates included as of 10 October 2019.
How IEEE 828 changed in 2012
Earlier editions only defined what a configuration management plan should contain. The 2012 edition added process requirements for identifying and acquiring configuration items, controlling changes, reporting status, and software builds and release engineering.
IEEE says it is consistent with SWEBOK and with ISO/IEC/IEEE 12207:2008 and 15288:2008. Treat it as a stable reference, not a living specification.
Maturity and security frameworks
CMMI V3.0 lists Configuration Management as a core practice area. Its practices cover identifying items, maintaining a configuration and change management system, managing changes, keeping records and performing audits.
NIST SP 800-128 narrows the scope to information security, which NIST calls security-focused configuration management. It applies to federal information systems and supports the controls in NIST SP 800-53.
How to set up software configuration management on a project
- Write the configuration management plan, covering policies, roles, tools and the audit schedule.
- List the configuration items and fix a naming and versioning scheme for each.
- Record the first baseline after the first clean build and test run.
- Automate the build and release from tagged baselines.
- Set the approval path for changes, scaled to the risk of the item.
- Schedule status reports and audits, then run the first one early.
Order matters. A baseline recorded before the item list exists freezes whatever files happened to be nearby.
Step four is where a build pipeline pays off. It compiles every tagged baseline the same way, and a failed build blocks the merge.
A release that cannot be undone is a weak baseline. Keep a tested path for rolling back a deployment to the previous tag.
What the configuration management plan holds
ISO 10007:2017 outlines the plan in its Annex A, starting with an introductory section and policies, then configuration identification, change control, status accounting and audit.
IEEE 828-2012 describes content areas for the plan as well, so either document works as a template.
When does software configuration management fall short?
Most of the trouble comes from applying more process than the situation calls for.
Approval bottlenecks
ISO 10007 and EIA-649C both give change control its own function. DORA, though, found no evidence that formal external review lowers change failure rates, and it suggests moving approval closer to the work.
Both hold once the control sits where the change is made. Peer review and automated checks cover routine changes, and the change control board handles the high-risk ones.
DORA’s 2017 Capital One case study credits trunk-based development and automated change control for a 20x increase in releases with no increase in incidents. Lighter change management didn’t cost the bank any stability.
Large binary assets
GitHub warns at 50 MiB and blocks files over 100 MiB in regular Git history (GitHub Docs).
Baselines that include firmware images or design assets, or big datasets, run into that wall first. Route them through Git LFS or choose a version control tool built for large binaries.
Small teams and noncritical software
IEEE 828-1983 applied in full to critical software, where failure could cause safety problems or large financial or social losses. It allowed a subset of its requirements for noncritical software.
A two-person team on a hosted Git repository doesn’t need a board, quarterly audits or a status report. A smaller set of controls will do.
The minimum for a team already on Git and CI
- Peer review before anything merges to the main branch
- Annotated tags on every release
- CI builds from tags, never from a laptop
- Each change request linked to the commits that closed it
- A periodic check that what runs in production matches a tag
Together those cover identification, control, status accounting, audit and release in their smallest form. Add the formal board when a contract or regulator asks for one.
Software Configuration Management FAQ
What does a configuration manager do?
Owning the configuration management plan is the core of the job. The role also cuts and records baselines, publishes status reports and schedules audits.
On small teams, a build engineer or senior developer carries the role.
Does software configuration management work with agile and CI/CD?
Yes. Short iterations change how often baselines are cut, not whether they exist.
Pipelines in Jenkins or GitLab CI build from tagged commits, so each release still traces to a recorded baseline.
What is a release candidate, and when does it become a baseline?
Once a build contains everything the release needs and enters final testing, it’s a release candidate. If no blocking defect turns up, that exact build ships and its tag becomes the product baseline.
Rebuilding after testing voids the results, so a release candidate ships as built or gets replaced by a new one.
How is a configuration audit different from a code review?
A code review inspects one change before it merges, so it happens for every change.
A configuration audit checks the finished item against its requirements (functional audit) and against its documentation and baseline (physical audit). It’s tied to a baseline instead.
What is a configuration management database?
Records of configuration items and the relationships between them live in a configuration management database.
ITIL uses one for IT services and assets, so a source repository doesn’t count as one.
Where did software configuration management come from?
The roots are in military systems engineering. The USAF issued MIL-STD-483, Configuration Management Practices for Systems, Equipment, Munitions, and Computer Programs, in 1970.
According to StickyMinds, SCCS (1972) became the first widely used version control tool, and IEEE 828 first covered software configuration management plans in 1983.
When to Add Formal Controls Beyond Git and CI
Teams add controls in a sensible order. Baselines come first, because every later control compares against one. Approval comes next, scaled to the risk of the item, and audits follow to check both. A team should climb a step only when a contract, regulator or release risk demands the evidence.
Read together, the subset rule in IEEE 828-1983 and DORA’s finding on external review point the same way. Reserve board approval for items whose failure causes safety or financial loss.
Verified on 7 November 2026. A published ISO 10007 revision, or a contract citing a specific standard, would change this order. Before the first formal audit, check how a software audit process runs in practice.
- Who Answers Your Users After Launch? - November 18, 2026
- How to Create a Folder in GitHub From the Browser - November 17, 2026
- 6 Best Cookie Consent Apps for Shopify in 2027: Features and Setup Compared - November 17, 2026



