Imagine the night before your final-year project demo. Three teammates have been editing the same code, someone emails project_final_v3_REAL.zip, the demo machine has a different library version, and a bug fixed last week is mysteriously back. Every one of these problems is a configuration management failure.
In Software Maintenance & Reengineering we saw that software changes constantly throughout its life. Software Configuration Management (SCM) is the discipline that keeps that change under control: it tells you exactly what makes up each version, who changed what and why, and how to rebuild any release. This chapter covers configuration items, baselines, the classic SCM activities, the change control process, version control with Git (with real commands and output), branching strategies, semantic versioning and configuration audits.
Software Configuration Management is the set of activities that identify the items making up a software system, control changes to them, record and report their status, and verify that the system is complete and consistent, throughout the software life cycle.
Note that SCM is an umbrella activity: it runs from the first requirements document until the product is retired, not only during coding.
Why SCM Is Needed
Without SCM, teams hit the same problems again and again:
| Problem | What it looks like | How SCM prevents it |
|---|---|---|
| Lost changes (simultaneous update) | Two people edit the same file; the second save overwrites the first | Version control with merging |
| Regressed fixes | A fixed bug reappears because an old copy of a file was used | Single source of truth, baselines |
| "Works on my machine" | Different library or tool versions on each machine | Configuration items include dependencies, build scripts and environments |
| Unknown release contents | Customer reports a bug in "the March version", nobody knows exactly what that was | Tagged releases, status accounting |
| Uncontrolled changes | A developer adds a feature nobody approved; scope creeps | Change control process |
Software Configuration Items (SCIs)
A software configuration item (SCI) is any work product that is placed under configuration management and treated as a single unit for identification, change and versioning.
SCIs are not just source code. Typical SCIs:
SRS, design documents, UML models (see Software Requirements Specification (SRS) and UML Diagrams)
Source code, database schemas and migration scripts
Test plans, test cases, test data and test scripts
Build scripts, CI pipeline files, Dockerfiles, infrastructure-as-code files
Third-party libraries and their exact versions (lock files such as
package-lock.jsonorrequirements.txtwith pinned versions)User manuals and release notes
Sometimes even the tools themselves: compiler version, IDE settings
Each SCI gets a unique identifier, a version and a record of its relationships to other SCIs (for example, "design module D4 implements requirements R7–R9 and is tested by TC40–TC52"). These relationships make impact analysis possible when something changes.
Baselines
A baseline is a formally reviewed and agreed version of one or more SCIs that serves as the basis for further development, and that can be changed only through formal change control.
Before an item is baselined, its author can change it freely. After it is baselined, changes must go through the change control process. A baseline is like a "save point" the whole team agrees on.
Requirements ──► Design ──► Code ──► Testing ──► Release
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
[Requirements] [Design] [Code [Test- [Product /
baseline] baseline] baseline] ready release
(approved (approved (reviewed baseline] baseline]
SRS) design) code)
Before a baseline: informal change (author decides)
After a baseline: formal change (change request → approval)
Some standards use the names functional baseline (approved requirements), allocated baseline (requirements allocated to components) and product baseline (the approved, built product).
Versions, Revisions, Variants and Releases
| Term | Meaning | Example |
|---|---|---|
| Version | An instance of an SCI that differs in some way from other instances | fees.py at commit 1c5bbd3 |
| Revision | A new version intended to replace the old one (sequential) | 1.0 → 1.1 after a bug fix |
| Variant | A version meant to exist alongside others (parallel), e.g. for different platforms or customers | Android and iOS builds; Hindi and English editions |
| Release | A version distributed to customers or users | v1.1.0 deployed to the college on 1 July |
Version control systems do not need to store every version as a full copy. Older systems such as RCS stored the latest version in full plus deltas (differences) to reconstruct earlier ones. Git stores each version as a snapshot of content-addressed objects and compresses similar objects into delta-encoded pack files, so storage stays small either way.
The SCM Activities
Standards such as IEEE 828 organise SCM around a plan and four core activities. This four-part list is the classic exam answer:
| Activity | Question it answers | Typical outputs |
|---|---|---|
| Configuration identification | What are the items, and how do we name and version them? | List of SCIs, naming scheme, baselines, repository structure |
| Configuration (change) control | How is a change requested, evaluated, approved and implemented? | Change requests, CCB decisions, change orders |
| Configuration status accounting | What changed, when, by whom, and what is the state of every change? | Change logs, release notes, status reports |
| Configuration audit | Does the product match its requirements and its documented configuration? | Audit reports (functional and physical audits) |
Around these sit SCM planning (a Configuration Management Plan stating policies, tools and responsibilities) and release management (building, packaging and delivering releases). Pressman lists the SCM tasks as identification, version control, change control, configuration auditing and status reporting, which covers the same ground with version control as its own item.
Change Control
Change control balances two risks: too little control lets chaos in, too much control stops useful changes. For baselined items the classic process is:
Need for change recognised
│
▼
Change Request (CR) submitted ── e.g. "CR-17: add 25% concession for EWS"
│
▼
Change evaluated: impact analysis, effort, risk, affected SCIs
│
▼
Change Control Board (CCB) / change authority decides
│ │
rejected approved
│ │
requester informed Engineering Change Order (ECO) issued:
what to change, constraints, review criteria
│
▼
Check-out affected SCIs (access control)
│
▼
Make change ──► review / test (incl. regression)
│
▼
Check-in (synchronisation control), new baseline,
status accounting updated, release planned
The Change Control Board (CCB) may be a formal committee (customer, manager, architect, QA) in a large or safety-critical project, or simply the product owner and tech lead in a small agile team.
Access control decides who may check out and change an SCI; synchronisation control stops two people from overwriting each other's changes.
In modern teams, a pull request with required reviewers and passing CI checks is a lightweight change control step: nothing merges into the protected
mainbranch without approval.
Version Control Systems
A version control system (VCS) is the main tool for identification, synchronisation and status accounting of code-level SCIs.
| Aspect | Centralised (e.g. Subversion, CVS) | Distributed (e.g. Git, Mercurial) |
|---|---|---|
| Repository | One central server holds the history | Every clone has the full history |
| Working offline | Commits need the server | Commit, branch, diff, log all work offline |
| Single point of failure | Server loss can lose history (without backups) | Any clone can restore the repository |
| Branching and merging | Heavier, often avoided | Cheap and routine |
| Fine-grained access control | Easier (per-directory permissions) | Usually at repository/branch level via the hosting platform |
| Typical use today | Some enterprises, large binary assets | The vast majority of new projects |
Git in action: branches, a conflict and a tagged release
Let's walk through two change requests on a tiny fee module. CR-17 (EWS concession) is developed on a feature branch while CR-18 (PG fee increase) is made on main.
git init -b main fee-portal && cd fee-portal
printf 'BASE_FEE = {"UG": 45000, "PG": 60000}\n' > fees.py
git add fees.py
git commit -m "Add base fee table"
git tag -a v1.0.0 -m "Release 1.0.0" # baseline for release 1.0.0
git switch -c feature/ews-concession # CR-17 on its own branch
printf 'CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}\n' >> fees.py
git commit -am "Add EWS concession (CR-17)"
git switch main # CR-18 directly on main
sed -i 's/60000/62000/' fees.py
git commit -am "Raise PG fee to 62000 (CR-18)"
git merge feature/ews-concession -m "Merge CR-17"
Output of the merge:
Auto-merging fees.py
CONFLICT (content): Merge conflict in fees.py
Automatic merge failed; fix conflicts and then commit the result.
Both branches changed neighbouring lines of the same file, so Git cannot decide automatically. It marks the conflict inside the file:
<<<<<<< HEAD
BASE_FEE = {"UG": 45000, "PG": 62000}
=======
BASE_FEE = {"UG": 45000, "PG": 60000}
CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}
>>>>>>> feature/ews-concession
The part between <<<<<<< HEAD and ======= is main's version; the rest is the feature branch's. A human must decide: we want both changes, the new PG fee and the concession table. This is the "synchronisation control" problem solved safely: nothing was silently overwritten.
printf 'BASE_FEE = {"UG": 45000, "PG": 62000}\nCONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}\n' > fees.py
git add fees.py
git commit -m "Merge CR-17: EWS concession"
git tag -a v1.1.0 -m "Release 1.1.0" # new release baseline
git log --oneline --graph --decorate --all
Output:
* 98d8a3b (HEAD -> main, tag: v1.1.0) Merge CR-17: EWS concession
|\
| * 9258274 (feature/ews-concession) Add EWS concession (CR-17)
* | 1c5bbd3 Raise PG fee to 62000 (CR-18)
|/
* 62a2817 (tag: v1.0.0) Add base fee table
Now status accounting questions have exact answers. "What changed between the two releases?"
git diff v1.0.0 v1.1.0
diff --git a/fees.py b/fees.py
index f217937..11e8e5d 100644
--- a/fees.py
+++ b/fees.py
@@ -1 +1,2 @@
-BASE_FEE = {"UG": 45000, "PG": 60000}
+BASE_FEE = {"UG": 45000, "PG": 62000}
+CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}
"Which change introduced each line?"
git blame -s fees.py
1c5bbd3f 1) BASE_FEE = {"UG": 45000, "PG": 62000}
92582747 2) CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}
Because each commit message names its change request, every line traces back to an approved CR. (Commit hashes will differ on your machine, since they depend on author, time and content.)
Mapping Git to SCM concepts
| SCM concept | Git feature |
|---|---|
| Configuration identification | Files in the repository, commit hashes, tags |
| Baseline / release | Annotated tag (v1.1.0), release branch |
| Change request / ECO | Issue in the tracker, pull request |
| CCB approval | Required reviews and branch protection rules |
| Synchronisation control | Merge, conflict detection |
| Status accounting | git log, git diff, git blame, release notes |
| Variants | Long-lived branches or build-time configuration flags |
Branching Strategies
| Strategy | How it works | Suits |
|---|---|---|
| Git Flow | Long-lived main and develop; feature, release and hotfix branches | Products with scheduled, versioned releases (installed software, mobile apps) |
| GitHub Flow | One main that is always deployable; short feature branches merged via pull requests | Web apps deployed continuously |
| Trunk-based development | Everyone integrates into trunk at least daily; very short branches or none; unfinished work hidden behind feature flags | Teams practising CI/CD at high frequency |
The longer a branch lives, the harder its merge, which is why DevOps & CI/CD recommends integrating small changes often.
Semantic Versioning
Release identifiers should carry meaning. Semantic Versioning 2.0.0 (semver.org) is the most widely used scheme: MAJOR.MINOR.PATCH.
| Increment | When | Example |
|---|---|---|
| MAJOR | Incompatible (breaking) change to the public API | 2.4.1 → 3.0.0 (API renamed payFee to createPayment) |
| MINOR | New functionality, backward compatible | 2.4.1 → 2.5.0 (EWS concession added) |
| PATCH | Backward-compatible bug fixes | 2.4.1 → 2.4.2 (rounding bug fixed) |
Incrementing MINOR resets PATCH to 0; incrementing MAJOR resets both.
Pre-release versions add a hyphen:
3.0.0-alpha.1,3.0.0-rc.2. A pre-release has lower precedence than the normal version: 3.0.0-rc.2 < 3.0.0.Build metadata follows a plus sign,
3.0.0+build.57, and is ignored when comparing precedence.Major version 0 (0.y.z) means initial development: anything may change at any time.
Build and Release Management
A release is only reproducible if everything that went into it is controlled:
Automated builds from a clean checkout, never from a developer's laptop.
Pinned dependencies via lock files, so the same tag always pulls the same library versions.
Artifact repositories store the exact built binaries or container images for each release, labelled with the version and commit.
Configuration as code: environment settings and infrastructure definitions live in version control too (secrets excluded, kept in a secrets manager).
Release notes generated from the change log, listing the CRs included.
Configuration Audits
Change control ensures that changes are approved; audits check that the result is correct and complete.
| Audit | Checks | Example question |
|---|---|---|
| Functional Configuration Audit (FCA) | The product's actual functionality and performance meet its requirements (based on test results) | Do the test reports show every requirement in the SRS was verified? |
| Physical Configuration Audit (PCA) | The delivered product matches its documented configuration | Does release 1.1.0 contain exactly the files, versions and documents listed in its baseline? |
Pressman's audit questions are a useful checklist: Was the change specified in the ECO made, with no extra modifications? Was a technical review held? Were SCM procedures (noting the change, date, author) followed? Were all related SCIs updated?
Common Mistakes
Treating SCM as "just Git". Version control is one tool; SCM also covers identification, change approval, status accounting and audits, across all work products.
Putting only source code under control. Requirements, tests, build scripts and dependency versions are SCIs too.
Confusing a version with a baseline. Every commit is a version; a baseline is a reviewed, agreed version that changes only through change control.
Confusing revisions and variants. A revision replaces its predecessor; a variant lives alongside other variants.
Resolving merge conflicts by blindly picking one side. That silently drops someone's approved change.
Committing secrets or build outputs into the repository.
Calling a breaking change a minor version. Under SemVer, any incompatible API change requires a MAJOR increment (after 1.0.0).
Interview and Exam Questions
Q1. What is a software configuration item? Give examples.
Any work product placed under configuration control and managed as a unit: SRS, design models, source files, test cases, build scripts, dependency lists, user manuals.
Q2. What is a baseline and why is it important?
A formally reviewed and agreed version of one or more SCIs that can be changed only through formal change control. It gives the team a stable reference point and makes it possible to know and rebuild exactly what was approved or released.
Q3. List and explain the main SCM activities.
Configuration identification (naming and versioning items, defining baselines), change control (evaluating and approving changes), status accounting (recording and reporting what changed and the state of every change) and configuration audit (verifying functional and physical correctness). Plus SCM planning and release management.
Q4. Describe the change control process.
A change request is submitted and evaluated (impact, cost, risk). The change control board approves or rejects it. If approved, an engineering change order is issued; the SCIs are checked out, changed, reviewed and tested, then checked in, a new baseline is set and status accounting is updated.
Q5. Differentiate centralised and distributed version control.
Centralised VCS keeps history on one server and needs it for commits; distributed VCS gives every clone the full history, supports offline work and cheap branching, and has no single point of failure.
Q6. A library is at 2.3.4. What is the next version for (a) a bug fix, (b) a new backward-compatible function, (c) removing a public function?
(a) 2.3.5, (b) 2.4.0, (c) 3.0.0.
Q7. What is the difference between a functional and a physical configuration audit?
FCA verifies that the product meets its functional and performance requirements; PCA verifies that the delivered product and its documentation match the recorded configuration baseline.
Q8. How does a pull-request workflow implement SCM?
The PR is a change request tied to an issue; required reviewers and CI checks act as the change control board; protected branches enforce access control; merge handles synchronisation; the commit history, tags and release notes provide status accounting.
Summary
SCM is an umbrella activity that controls change across the whole life cycle.
SCIs include every controlled work product, not just code. Baselines are reviewed, agreed versions changed only via formal change control.
Revisions replace earlier versions; variants exist side by side; releases go to users.
Core activities: identification, change control, status accounting, audit (plus planning and release management).
Change control: CR → evaluation → CCB → ECO → check-out → change and review → check-in → new baseline.
Git provides versioning, branching, conflict detection, tags as baselines and log/diff/blame for status accounting.
Branching strategies: Git Flow, GitHub Flow, trunk-based. SemVer: MAJOR.MINOR.PATCH.
FCA checks the product against requirements; PCA checks it against its documented configuration.
If you cannot say exactly what is in a release and how it got there, you do not control your software; SCM is how you get that control.