The local requirement is reasonable. The developer says it is a small change. Neither statement tells you what happens when the next release arrives.

Configure a digital public good where its supported options meet the service need. Where they don't, assess an extension, an upstream contribution or a maintained fork against the same requirement, including who will test and maintain it through upgrades. Sometimes changing the operating process is the better answer. Sometimes the product is the wrong fit.

The decision belongs in a change record before code is altered. “Open source means we can change it” establishes a possibility, subject to the licence. It doesn't appoint the person who will keep that change working.

Four routes, with different obligations

RouteWhat changesWhat you still own
ConfigurationSupported settings, forms or other documented optionsVersion control, validation and checking changed behaviour after upgrades
ExtensionA separate component using an available supported interfaceIts code, dependencies, interface compatibility and operations
Upstream contributionA proposed change to the shared productWork before acceptance, review responses and a plan if it is delayed or declined
Maintained forkA local code line diverging from the shared productReconciliation, security updates, regression tests and a future exit

These are working distinctions for a commissioning decision. Products use different terminology, architectures and contribution processes. An extension route only exists if the product exposes an appropriate interface; putting code in another repository doesn't magically make it supported.

Equally, configuration may involve technical files rather than a convenient screen. Classify the change by its relationship to the supported product, not by whether someone had to type code.

What the OpenCRVS example shows

The OpenCRVS FAQs distinguish configuration of application settings, form fields and certificates from changes to the core code. They warn that code customisation creates additional work when applying future core updates and recommend discussing significant changes with the product team.

That illustrates the upgrade question. It isn't evidence that every DPG has the same configuration features, extension model or upstream process. Check the documentation and maintainers for the exact product and release you plan to use.

I lead commercial partnerships at OpenCRVS; my role is disclosed on its partner programme page. The framework below is a way to record your own choices, not a promise that a particular change will be accepted into OpenCRVS or any other product.

Establish why the change is needed

Describe the required service behaviour without prescribing an implementation. Attach the evidence: an approved policy, a legally reviewed requirement, a user test or a quantified operational problem. A request to reproduce the old screen isn't yet a requirement to modify the core.

Separate non-negotiable obligations from preferences. If a statutory certificate format is mandatory, have the responsible authority confirm the required fields and approval route. If a manager prefers the old field order, test whether supported configuration or a process adjustment solves the problem.

For each change, identify the service owner who can accept the result and the technical owner who will maintain it. Ask what happens if it is deferred. That answer helps distinguish a release blocker from a nice-to-have.

The requirement should survive the loss of its preferred solution. If nobody can explain it without naming a code change, there is more analysis to do.

Yellow and green cables are neatly connected
Illustrative photograph, not a record of an engagement. Photo: Albert Stoynov / Unsplash.

Work through three different decisions

These are illustrative choices. They are not claims about features available in every DPG.

A certificate needs approved wording. First check the selected release's documented certificate configuration and test its output with the responsible authority. If it meets the requirement, retain the configuration and approval evidence together. Don't patch the renderer merely because that is the first route the developer knows.

A legacy system needs a different message format. A separate adapter may be sensible if the DPG offers an appropriate supported interface. Specify authentication, field mapping, retries, duplicate handling and monitoring. The adapter still needs an owner and compatibility tests. Moving the code outside the core moves the maintenance boundary; it doesn't remove the work.

A new approval rule changes the product's workflow. Ask the maintainers whether a supported option exists and whether the need fits the shared product. An upstream proposal may be worth pursuing. Until it is accepted and released, plan against the product that exists. If the deadline cannot move, the sponsor must decide whether to fund a maintained local change, alter the scope or choose another approach.

A fork can be a deliberate engineering decision. An undocumented fork with nobody funded to maintain it is a programme risk.

Test the upgrade before approving the change

Ask the team to map the proposed change to the files, interfaces, data structures and user journeys it affects. Record the baseline version, dependencies and test environment. Then define the upgrade rehearsal you expect to run when a relevant release arrives.

  1. Apply the new release to an isolated environment with synthetic or appropriately protected test data.
  2. Reapply or migrate the local configuration and changes using documented steps.
  3. Run the affected service journeys, permissions, interfaces and data-migration checks.
  4. Measure the reconciliation effort and record unresolved defects.
  5. Prove the agreed recovery approach before authorising production rollout.

A database change can make simply reinstalling the old application unsafe. The recovery plan must cover data as well as code. Have the technical team establish what rollback or forward recovery is actually supported rather than accepting “we'll revert it”.

Agree who watches security releases and who can authorise urgent remediation. A routine upgrade calendar should not be the only route to handling a critical issue.

Compare lifecycle effort, not just build effort

Use the same planning horizon for every option. Include initial analysis and delivery, testing for each assumed upgrade, dependency maintenance, operational support and eventual removal or migration of the change. Keep uncertainty visible. You will not know the exact work in future releases.

For a deliberately simple example, suppose a local change takes 12 engineering days initially. Over two years, assume four upgrade rehearsals at three days each, plus two days per year maintaining tests and runbooks. That is 12 + 12 + 4 = 28 engineering days before hosting, incidents or any exit work. At an illustrative £600 per day, it is £16,800. These are invented planning assumptions, not a market rate or a forecast for a DPG.

Change the assumed upgrade effort to six days each and the total becomes 40 days, or £24,000 at the same rate. The point is to expose the variable that matters. A quotation for the initial 12 days doesn't tell you which scenario you are buying.

Budget the right to keep changing your mind. Give each local change a review date and a retirement condition, such as equivalent supported functionality becoming available. The existing guides on digital sovereignty and support after go-live cover the broader ownership question.

Keep a change decision record

Download the configuration and customisation decision register (CSV). It includes separate example rows for configuration, an extension, an upstream proposal and a fork, with prompts for evidence, upgrade testing, maintenance ownership, effort assumptions and retirement. It has no automatic calculations or macros.

Use one row per requirement, not one decision for the whole programme. A sensible implementation can use several routes. Leave an option unapproved until the service owner accepts the behaviour and the technical owner accepts the maintenance obligation.

For a review of those trade-offs, see my open-source and DPI work or let's discuss the changes your programme is considering. Bring the requirement and the upgrade plan together.

Frequently asked questions

Does configuration mean there is no upgrade work?

No. You still need to check that settings remain valid and the service behaves as intended on the new release. Supported configuration can reduce divergence without removing testing, migration or approval work.

Can an upstream contribution be a launch dependency?

Only with a credible plan for the uncertainty. Discuss review and release expectations with the maintainers, and agree a fallback if the change is delayed or declined. A submitted patch is not a released feature.

Is maintaining a fork always the wrong decision?

No. It can be justified where the requirement is necessary and alternatives are unsuitable. Approve it with a funded owner, upgrade and security process, test coverage and a review or exit condition. The concern is an unmanaged obligation, not the label.

Can a local change be removed later?

Sometimes, but check its data and operational consequences. Removing code may leave records, interfaces or staff procedures dependent on it. Include migration, reconciliation and user acceptance in the retirement plan where needed.