ERP Solutions

Software package modifications: a very costly habit

Before modifying an ERP package, compare standard processes, configuration and an extension using vendor-supported mechanisms. Approve an adaptation only when the business need justifies design, testing, support and future upgrade costs. Require a named owner, documentation and measurable acceptance criteria before committing to development.
•
image of an innovation lab (for an AI developer tools business)
Key takeaways
  • Software package modifications are expensive in three ways: development, maintenance, and every version update.
  • The recommended approach is to adopt the standard business processes supported by the software (the "vanilla" approach).
  • Before any modification: a complete analysis of costs (design, maintenance, support, migration) and actual benefits.
  • As a last resort, an extension adds functionality without compromising the software's integrity.

Modifying software packages is expensive in every respect. You could compare them to ice cream flavours: in the world of software packages, there is no better flavour than vanilla. In other words, modifications often leave a bitter aftertaste.

We therefore suggest adopting the business processes supported by the software packages, an approach that is much more efficient than forcing the software to fit your organization through modifications.

Why are software package modifications so expensive?

Because they are costly three times over: during development, during maintenance, and then with every software update, where they must be reviewed and adapted to the new version. They also represent major risk factors for an implementation project. No modification should be implemented without a complete cost-benefit analysis.

When moving to a new version, any modifications made must be reviewed and adapted. This is a costly operation that delays the migration project timeline. It is also very possible that the team that originally developed the modification is no longer available and that the documentation is nowhere to be found.

In extreme cases, excessive modifications can even prevent the manufacturer from honouring its support contract: a serious issue if the software package requires an update or maintenance.

In the world of software packages, there is no better flavour than vanilla.

What should you check before modifying a software package?

All costs related to the design, maintenance, support, and eventual migration of the modification, as well as the actual benefits it provides. These change requests are, in fact, one of the main causes of overruns in ERP project budgets.

If the need persists, check with the manufacturer first: the functionality might be included in the next version of the software package. You can also ask them to develop the modification, or at the very least, to review your design and provide a quote for supporting it once the modification is in production.

Why were modifications common 20 years ago? Software packages offered fewer features and were less complex. Today, they generally support the most common and recognized business practices.

Process-mapping workshop before choosing an ERP adaptation.
Define the business requirement before choosing a technical modification.

What is the difference between a modification and an extension?

An extension adds functionality without touching the core of the software package, whereas a modification alters the product itself. Some elements are not considered modifications: interfaces, data conversion programs, and reports. Interfaces are often essential for integrating the software package with the organization's other applications, even if they remain costly to develop and test.

However, creating an extension must follow certain rules. First, you should never create records directly in the software package's database: if it is necessary to create them, you must use the interfaces provided by the manufacturer.

Don't forget to document all modifications, extensions, and interfaces. These documents are gold mines: they support the software package's production and the migration to the next version.

Before making modifications, remember the reasons that led you to choose a software package: to avoid custom development, to easily access new versions, and to benefit from best business practices. Modifications may seem economical in the short term; they will not simplify your processes in the medium or long term, nor will they simplify the transition to the next version. It is something to think about carefully.

Configuration, extension or modification: how should you decide?

An established internal habit does not automatically justify development. A traceability requirement or contractual commitment may justify an adaptation. Ask the process owner to describe the need before selecting the technical approach.

Decision grid before customizing an ERP
OptionWhen to choose itEvidence before approval
Standard processThe need is met by changing an internal practiceDemonstration using representative data and business approval
ConfigurationAvailable settings and rules cover the requirementDocumented settings, access rights and exception tests
Extension or interfaceThe need remains and vendor-supported mechanisms can address itCompatibility, rejection handling and support ownership confirmed
Core modificationExceptional case after alternatives have been assessedSupport terms, upgrade costs, replacement option and executive approval

Example for a Quebec manufacturing company

Fictional example. A manufacturer with 180 employees wants to reproduce an old shipping form. First assess standard documents, configurable fields and reporting options. If the underlying need is lot traceability, test the complete transaction chain rather than approving the appearance of the form alone.

A distributor may need a carrier interface; a professional services company may need a project billing rule. An interface does not necessarily change the product core, but it adds security, monitoring and recovery responsibilities. Calling it an extension does not eliminate its costs.

What acceptance criteria should a development request include?

Connect the requirement, expected result and evidence of success. Approve the following before development begins.

  1. A business owner and a verifiable consequence if the need remains unmet.
  2. Evidence that standard and configurable options have been assessed.
  3. Access rules, affected data and error handling.
  4. A normal scenario and an exception scenario with expected results.
  5. Initial cost, support, recurring tests and upgrade conditions.
  6. Contractually defined code, documentation, usage rights and replacement arrangements.

Frequently asked questions

What is a "vanilla" approach to software package implementation?

It is implementing the software package without modification, by adopting the standard business processes it supports. This approach reduces development and maintenance costs, simplifies updates, and reduces compatibility risk; support remains subject to the contract.

Why do modifications complicate updates?

With every new version of the software package, modifications must be reviewed, adapted, and retested. The operation is costly and delays migration, especially if the original team is no longer available or if documentation is missing.

What are the alternatives to modifying a software package?

Four options: adopt the software's standard process, wait for the feature in a future release, have the vendor develop the modification, or create an extension that adds the functionality without compromising the product's integrity.

Is an ERP extension risk-free during upgrades?

No. An extension can avoid changing the core product, but it must remain compatible with interfaces and versions. Plan regression tests, name a support owner and document how to remove or correct it.

Before customizing the software package, align the request with your business goals, architecture, and roadmap. See our independent ERP scoping.

Primary source: PlanAxion recommendations based on our experience in implementing, evolving, and supporting software packages.