Skip to content
Tutorials Center
My learning

Topics

Lesson 40 of 50 ยท Management, Risk and Professional Practice

Configuration and Change Management

Learn baselines, version identifiers, release notes, change requests and semantic versioning, with a JavaScript semver parser, sorter and bumper.

Software changes constantly: new features, bug fixes, new library versions, new settings. Configuration management is the discipline of knowing exactly what you have at any moment: which version of which file belongs to which release, and how to rebuild it. Change management is the companion discipline of deciding which changes to make, in what order, and with whose approval. Together they answer two questions every team eventually gets asked: "What exactly is running in production?" and "Who changed this, and why?"

The real tools here (Git, package managers, issue trackers, release pipelines) cannot run on the site, so their commands and files appear as read-only blocks. The runnable examples are JavaScript stand-ins that implement the heart of semantic versioning: a parser, a comparator, and a bumper that reads commit messages. They are small teaching versions, not a replacement for a real semver library.

What gets managed: configuration items

A configuration item (CI) is anything you must track and control as a unit. Source code is the obvious one, but a release depends on much more:

  • Source files, build scripts and infrastructure definitions
  • Third-party dependencies and their exact versions (a lock file)
  • Configuration files and environment settings
  • Database schema migrations
  • Requirements, design documents and test suites
  • The built artifacts themselves (a container image, an installer)

The test is simple: if changing it could change how the product behaves or how you can rebuild it, it is a configuration item. The four classic activities of configuration management follow from that:

  1. Identification: decide what the items are and give each a unique name and version.
  2. Control: allow changes only through an agreed process.
  3. Status accounting: record what changed, when, why, and what state each item is in.
  4. Audit: verify that what is deployed matches what was approved.

Four activities of configuration management

Identify Name and version every item.
Control Changes go through a process.
Account Record what changed and why.
Audit Check reality matches the record.

If you cannot rebuild last month's release, you are not managing configuration.

1 / 2

Baselines and version control

A baseline is an approved, frozen snapshot of a set of configuration items. After the baseline is set, you can only change it through the change process. Examples: the requirements baseline signed off by the customer, the design baseline after architecture review, the release baseline tagged as "version 2.0". Baselines give you three things: a stable point to build on, a point to return to if something goes wrong, and a reference to measure changes against ("what changed since 2.0?").

A version control system such as Git makes baselines cheap. A commit records a snapshot, a tag gives a snapshot a human-friendly name, and a branch lets work proceed without disturbing a baseline. The details of those commands live in the Git tutorial; the practices that matter for configuration management are:

  • Everything in version control, including build scripts and configuration, so a release can be rebuilt from one tag.
  • Pin dependency versions with a lock file, so "it worked yesterday" cannot be caused by a silent library update.
  • Tag every release and never move a tag after publishing.
  • Keep secrets out of the repository; store them in a secret manager and reference them by name.
TEXT
git tag -a v2.4.1 -m "Release 2.4.1"
git push origin v2.4.1

The commands above are read-only. A release tag like v2.4.1 is the baseline: later you can check out exactly that state, compare it to v2.4.0, or build a hotfix on top of it.

Branching and merging

Parallel work creates the central configuration problem: two people change the same file. Teams control this with a branching strategy, such as short-lived feature branches merged through code review, or trunk-based development with frequent small merges (see version control, CI and delivery pipelines). Whatever the strategy, the rule is the same: merges happen through a recorded, reviewed step, and the main line is always in a state you could release or at least build.

Change requests

Not every change should be made just because someone asked. A change request (CR) is a formal proposal to alter a baselined item. In an agile team it is often just a backlog item; in a regulated project it is a form with an approval chain. Either way, a good change request answers:

  • What is to change, and why (the problem or opportunity)?
  • Who asked, and who is affected?
  • Impact: which requirements, components, tests and documents change? What does it cost in time and effort?
  • Risk: what could go wrong, and how will it be rolled back?
  • Priority and decision: approved, rejected or deferred, by whom, and when?
flowchart LR
    A["Request submitted"] --> B["Impact analysis"]
    B --> C{"Approved?"}
    C -- "Yes" --> D["Implement and test"]
    D --> E["Release and update baseline"]
    C -- "No or later" --> F["Close or defer with reason"]

The usual life of a change request. The impact analysis step is where most bad changes are caught.

Many teams use a change control board (CCB), a small group that approves changes to baselines. The size of the board should match the risk: one person for a small team's internal tool, a formal committee for a medical device. The point is not bureaucracy; it is that someone who sees the whole picture says yes before a change lands. Fast teams shrink the process, but they keep its purpose: impact analysis, a recorded decision, and a trail.

Traceability links the pieces together: a change request points to the requirement it affects, the commits that implement it, the tests that cover it, and the release that shipped it. See the SRS lesson for the requirement side. Without these links, "can we remove this feature?" turns into archaeology.

Versioning and semantic versioning

Every release needs an identifier. Dates (2026.11), build numbers (build 4812) and marketing names all work for products used by people. For libraries and APIs used by other programs, the identifier has a second job: it must tell the user how risky it is to upgrade. That is the idea of semantic versioning (SemVer), which uses three numbers:

TEXT
MAJOR.MINOR.PATCH     for example 2.4.1
  • Increase MAJOR when you make an incompatible change: code that worked with the old version can break.
  • Increase MINOR when you add functionality in a backward-compatible way.
  • Increase PATCH for backward-compatible bug fixes.

When MAJOR goes up, MINOR and PATCH reset to zero; when MINOR goes up, PATCH resets. Two refinements complete the format:

  • A pre-release suffix after a hyphen (1.0.0-rc.1) marks a version that is less stable than the plain release and sorts before it.
  • Build metadata after a plus sign (1.0.0+build.7) is information only and is ignored when deciding which version is newer.

Versions before 1.0.0 (0.x.y) mean "initial development": anything may change at any time. SemVer is a promise made by the maintainer, so it is only as good as the discipline behind it. The compatibility rules matter even more when you design APIs and interfaces, where "what counts as breaking?" is the hard question.

Consumers use these rules in version ranges. A dependency declared as "compatible with 2.4.1" usually means "any 2.x release at or above 2.4.1": you accept new features and fixes but not breaking changes. That works only if maintainers honor the contract.

Stand-in 1: parse, validate and sort versions

The first stand-in parses versions with a regular expression that follows the SemVer grammar (no leading zeros, no v prefix), then compares them using the official precedence rules: compare the three numbers, then a version with a pre-release is older than the same version without one, then compare pre-release identifiers piece by piece (numbers numerically, words alphabetically, numbers before words, shorter list first when the start is equal).

JS A semantic version parser and sorter

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Two results surprise newcomers. First, 1.10.0 is newer than 1.2.0, because the parts are compared as numbers, not as text; sorting versions as plain strings is a classic bug. Second, beta.11 comes after beta.2 for the same reason. The run also shows that 1.0.0 and 1.0.0+build.7 compare as equal (the result is 0), so the sort keeps them in their original order.

Release notes

Version numbers tell users how risky an upgrade is; release notes tell them what changed. Good release notes are written for the reader, not copied from the commit log:

  • Group changes by kind: Breaking changes first, then Added, Changed, Fixed, Deprecated, Security.
  • Describe the effect on the user ("orders with no items are now rejected"), not the code ("refactor validator").
  • For every breaking change, say how to migrate.
  • Link to the change request or issue for details.
  • Keep one changelog file in the repository, newest release first.

Writing notes by hand is slow and error-prone, so many teams adopt a commit message convention, such as Conventional Commits: feat: for a feature, fix: for a bug fix, a ! after the type for a breaking change. A tool can then derive both the next version number and a draft of the release notes. The same convention also keeps the history readable for code review.

Stand-in 2: bump the version from commit messages

The second stand-in does what such tools do, in miniature: it reads commit messages, finds the highest-impact change (breaking beats feature beats fix), computes the next version with the reset rules, and prints a changelog draft. The commit list and format are invented examples; a real tool also handles footers such as BREAKING CHANGE:.

JS Derive the next version and release notes

Press Run (or Ctrl + Enter) to see the console output here.

No output.

One breaking commit decides the result: the next version is 3.0.0 even though the rest are small changes, and the minor and patch numbers reset. Delete the feat(api)! line from commits and run again; the answer becomes 2.5.0. Delete the feature too and it falls to 2.4.2. The docs: and chore: commits never change the version, since they do not affect users of the software. Remember that the stand-in only reports; a human still reviews the draft, because a tool cannot judge whether "return 404 for unknown orders" is secretly a breaking change for clients that relied on the old behavior.

Practical habits

  • Reproducible builds: the same inputs (tag, lock file, build script) should produce the same artifact. If two machines build different binaries from one tag, you cannot trust either.
  • Environment configuration: keep settings that differ between development, testing and production outside the code (environment variables or config files), and version the templates of those files.
  • Immutable releases: once published, a version is never changed. A mistake means a new version, not an edited old one.
  • Deprecate before removing: announce a removal in a minor release, then remove it in the next major one.
  • Record decisions: the reason a change was approved is as valuable as the change; see architecture decisions for a lightweight format.
  • Match ceremony to risk: a typo fix needs a quick review, a database schema change needs an impact analysis and a rollback plan.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What is a baseline in configuration management?

    A baseline is an agreed reference point such as a signed-off requirements set or a tagged release; changing it requires a controlled change.
  2. 2. Your library removes a public function that applications call. Under semantic versioning, which number must increase?

    Removing public behavior is an incompatible change, so MAJOR increases and MINOR and PATCH reset to zero.
  3. 3. Which version is the newest?

    Parts are compared as numbers, so 10 is greater than 9 and 2. A pre-release such as 1.10.0-rc.1 is older than the plain 1.10.0.
  4. 4. What is the main purpose of impact analysis in a change request?

    Impact analysis lists the affected requirements, components, tests and risks so that the decision to approve is informed.
  5. 5. Why should a published release never be edited in place?

    If a version can change silently, nobody can reproduce a build or know what they are running. Fix mistakes in a new version.

Summary

  • Configuration management identifies, controls, records and audits every item that affects a release; change management decides which changes happen and with whose approval.
  • A baseline is a frozen, approved snapshot; version control, tags and lock files make baselines cheap and builds reproducible.
  • A change request records what, why, impact, risk and the decision, and traceability links it to requirements, commits, tests and releases.
  • Semantic versioning (MAJOR.MINOR.PATCH, with pre-release and build metadata) tells users how risky an upgrade is; versions are compared as numbers, and build metadata is ignored.
  • Release notes group changes by kind for the reader, and a commit convention lets tools derive the next version and a draft changelog.

Next: Ethics, Security and Licensing.