Upgrades slow down when you change the core system and store the same data in many places. This duplication leads to poor data quality, such as duplicates, conflicts, and stale records.
According to Gartner, poor data quality alone costs organizations an average of $12.9 million each year, showing how weak data and change control push up costs and delay delivery.
When you keep the base steady and push changes into configuration, release APIs, and side-by-side extensions, you reduce conflicts and make upgrades smoother.
This article explains clean core implementation: the key steps, the best practices, and the role of master data management and low code to keep your core stable and ready for upgrades.
Learn more about the Clean Core Approach in our article titled “What is a Clean Core Approach?”.
What Is Clean Core Implementation?
Clean core implementation means running your system with the smallest possible changes to the standard core. You avoid altering the vendor’s base code and instead use in-app configuration, released APIs, and side-by-side extensions to meet your business needs.
The purpose is to keep your core system stable, upgradeable, and ready for future digital changes without constant rework.
When you customize the core too heavily, every upgrade becomes slow, expensive, and risky because the vendor’s updates conflict with your changes.
With a clean core, you shift those extensions outside the base so that upgrades flow in without major disruptions.
The trade-off is that you’ll need to plan which functions must stay standardized and which should move into modular extensions. If you keep unnecessary processes inside the core, you’ll face recurring technical debt.
Core Dimensions in a Clean Core
1. Processes
Processes are how your organization runs daily transactions, such as order-to-cash or procure-to-pay.
If you let every department design its own variations, you’ll create duplicate workflows that are hard to maintain. A clean process dimension means your system follows standardized process models with minimal exceptions.
Clean here means aligning to best practices, removing one-off workflows, and ensuring that processes can be measured and monitored without hidden manual steps.
2. Data
Data is the foundation of your clean core. Master data like customers, suppliers, and products is used across finance, sales, logistics, and HR. When records are inconsistent, even clean processes fail.
Clean in the data dimension means your system maintains accuracy, consistency, completeness, and synchronization across all consuming applications. It also means you’ll establish governance rules so ownership and changes are controlled.
3. Integrations
Integrations connect your core with external systems. Many organizations take shortcuts such as direct database calls or hard-coded point-to-point links, but those break as soon as the core system is upgraded.
A clean integration dimension means your system only uses stable, released APIs, middleware, or event-driven designs.
Clean also means each integration is documented, versioned, and monitored so you can trace data flows end-to-end.
4. Extensibility
Extensibility covers how you add features to your core system. If you modify the vendor’s core code, every upgrade requires you to retrofit those changes.
Clean extensibility means you extend the system only through in-app configuration or side-by-side development on low-code platforms.
This way, new business functions are modular, replaceable, and not tied to the vendor’s core updates.
5. Operations
Operations are about governance and lifecycle management. Even a system that starts clean can get polluted if you allow uncontrolled changes or lack monitoring.
Clean in operations means enforcing rules through governance bodies, continuous monitoring, and lifecycle controls such as CI/CD pipelines.
It also means running regular audits to check for unauthorized code or broken integrations.
Why Adopt Clean Core?
When you adopt a clean core, your system gains long-term agility. You can implement vendor updates, regulatory changes, or new digital initiatives without going through months of retrofitting.
For example, if your organization needs to roll out a new compliance rule, a clean core lets you configure it or extend it in a modular app.
A heavily modified system forces you to first rework old code before making the change, delaying compliance and increasing costs.
According to SAP, a clean core leads to a lower total cost of ownership and makes upgrades non-events from a custom-code standpoint. This means your organization avoids the recurring expense of repairing or rewriting custom code with every system update.
Another reason is data-driven transformation. Without clean data, predictive analytics, AI tools, and automation won’t produce reliable outcomes.
By aligning MDM with clean core, you ensure your analytics and automation efforts rest on a stable foundation.
The trade-off is discipline. Your organization must accept that not every custom request belongs inside the core.
Some business users may resist standardized processes, but allowing every exception leads to technical debt that eventually slows the entire system.
Key Steps in Clean Core Implementation
1. Assess Current System & Choose Migration Strategy
Assessment means examining the state of your existing system, including custom code, data quality, and process complexity. You’ll need to decide between two migration strategies: greenfield and brownfield.
Greenfield starts from a new system with minimal historical baggage. This path lets you standardize processes and keep the core clean from day one, but it requires significant change management since your teams will need to adjust to redesigned workflows.
Brownfield retains parts of your existing system while migrating to a clean core. The benefit is continuity of operations, but the challenge is stripping away outdated modifications without disrupting daily business.
The trade-off here is between speed and control. Greenfield provides a cleaner long-term foundation, while brownfield reduces immediate disruption but demands strict governance to avoid carrying old inefficiencies into the new environment.
2. Minimize Custom Code & Leverage Side-by-Side Extensibility
Custom code in the core creates technical debt because every system upgrade forces you to rework modifications.
A clean core requires you to minimize embedded customizations and shift new functionality to side-by-side extensions.
You can achieve this using low-code platforms where applications are built outside the core but still connected through APIs. eSystems supports this transition with Low-Code Value Consulting, which helps you identify “low-hanging fruit”, areas where extensions can deliver immediate value without complicating the core.
To scale this approach, eSystems offers the Digital Factory and Innovation Lab models.
The Digital Factory provides a structured framework where reusable assets are developed consistently across your organization.
The Innovation Lab allows you to experiment, prototype, and test digital ideas before committing resources.
Together, these approaches let you build scalable low-code solutions that extend your core without contaminating it.
3. Optimize Master Data (MDM) & Data Governance
Even if your codebase is clean, poor master data can compromise system reliability. Master data includes records such as customers, suppliers, and products that flow through every process.
If the same supplier appears under multiple IDs across finance and logistics, your reporting and compliance will be unreliable.
To keep data aligned with clean core principles, you need governance and harmonization. eSystems addresses this with its 5-step MDM approach:
Identify data sources
Curate data
Apply workflow
Harmonize and synchronize two-way across systems
Enable reporting
The Harmonization Orchestrator ensures data is synchronized across multiple systems, while the Management Console gives your teams direct control of master data without bypassing governance rules.
This approach reduces duplication, maintains a single source of truth, and ensures your clean core remains upgrade-safe and data-driven.
4. Standardize Integrations
Integrations are often the weakest link in system upgrades. Point-to-point links and direct database calls may work in the short term but become brittle and costly over time.
Clean core implementation requires a standardized integration framework based on APIs and event-driven designs.
eSystems supports this through its Low-Code Architecture and Integrations Strategy, which combines Workato automation with API-based connectivity.
This approach allows you to reduce complexity, increase visibility, and prevent integration failures during upgrades.
Standardized integrations ensure your system can evolve without re-engineering every connection.
5. Streamline Business Processes
Processes that are fragmented across departments or supported by outdated legacy applications add hidden costs and complexity. A clean core requires you to review, simplify, and standardize these processes.
eSystems enables this with Legacy Modernization and End-to-End Business Process Automation. Legacy Modernization helps you analyze your existing application portfolio and retire or replatform systems that no longer support your goals.
Business Process Automation, supported by low-code and integration tools, reduces reliance on manual work and ensures consistency across your organization.
By streamlining processes, you’ll not only protect your clean core but also remove silos that slow down decision-making.
6. Ensure Sustainable Operations & Governance
A clean core isn’t a one-time achievement. Without proper operations and governance, your system will slowly accumulate untracked changes and customizations.
eSystems supports sustainability through the Digital Factory, which applies a Center of Excellence approach across four dimensions: structure, talent, ecosystem, and process.
This model ensures your teams follow consistent practices, reuse digital assets, and apply governance rules to every extension or integration.
Continuous monitoring and lifecycle management prevent your system from drifting away from clean core principles.
Best Practices for Clean Core Implementation
1. Zero-Core Modifications
Zero core modifications means you don’t change the vendor’s base code. You use configuration and approved extension points to meet business needs.
Changing core code locks you into manual merges during upgrades because vendor patches collide with your edits.
Instead, run a fit gap review for each requirement and route it through a simple decision tree: configure if possible, use in-app tools when supported, or build outside the core when logic is custom.
The trade-off is that some features may sit outside the core and require API calls, but you’ll avoid recurring retrofit work.
Move custom pricing logic into an external rules app that calls the standard pricing API, rather than embedding exits in the core.
Pitfalls and controls: Hidden core edits through user exits, database triggers, or implicit enhancements.
Control this with transport approvals, code scanners, and a “no core change” policy enforced by your change board.
2. Use Only Stable, Released APIs for Extensions
Stable released APIs are vendor-supported interfaces with documented contracts and versioning. You use them to connect extensions without touching core code.
Relying on private endpoints or direct table reads creates brittle links that break on upgrade. You’ll standardize on REST or event interfaces with clear schemas, lifecycle tags, and deprecation paths.
Add contract tests to catch breaking changes early. The trade-off is that you’ll sometimes build extra adapters, but you’ll gain predictable upgrades and traceable data flows.
How eSystems helps: Through its low-code architecture and integrations strategy with Workato, eSystems designs extensions against released APIs and sets standard integration patterns so changes stay outside the core and upgrades remain predictable.
Pitfalls and controls: Direct database access, undocumented endpoints, and missing version headers. Control this with an API catalog, schema validation in CI, and backward-compatible releases.
3. Prioritize Master Data Quality
Master data quality means your records for customers, suppliers, materials, and employees are accurate, consistent, and synchronized across systems.
Clean code won’t help if two systems hold different truths. Set ownership, stewardship, and measurable data quality rules. Then implement an operational MDM flow so changes propagate in a controlled way.
How eSystems helps: The eSystems MDM Foundation follows five steps: identify sources, curate data, apply workflow, harmonize with two-way synchronization, and enable reporting.
The Harmonization Orchestrator coordinates updates across systems, while API services expose the golden record to consuming apps.
Pitfalls and controls: Duplicate records, conflicting updates, and latency. Control this with persistent business keys, match and merge logic, approval workflows, and audit logs so you can trace every change.
4. Embrace Side by Side, Modular Extensions
Side-by-side extensions are apps built outside the core that call released APIs or react to events. They add features without changing the base code.
This pattern lets you scale and release features on their own cadence. You’ll define domain boundaries so each extension owns a clear slice of logic and data. The trade-off is extra integration design, but you’ll isolate risk and keep upgrades simple.
How eSystems helps: Through Legacy Modernization and Low code in Practice, eSystems moves core customizations into side-by-side apps built in your Digital Factory, packages them as reusable digital assets, and connects them with released APIs and Workato so your core stays clean during upgrades.
Pitfalls and controls: Chatty interfaces, duplicated data, and weak access control. Control this with event-driven updates, caching where read-heavy, idempotent writes, and least privilege access for every service.
Conclusion
Clean core means you keep the base code unchanged and move changes into configuration, APIs, and extensions.
You have a path: assess your system, pick a migration strategy, remove custom code, fix master data, standardize integrations, and run governance.
The payoff is upgrade speed and fewer defects. Next, score opportunities, set contracts for APIs and events, and publish a roadmap with owners and checkpoints.
About eSystems
eSystems is a Nordic partner that helps you modernize with low code, automation, and master data management. We work with you to keep your core clean while you add capability through configuration, released APIs, and side-by-side extensions.
We provide Low Code Value Consulting to move custom logic out of the core. We define low-code architecture and an integration strategy and use Workato to standardize APIs and events.
We deliver an MDM foundation with a Harmonization Orchestrator, a Management Console, MD API services, an MD catalogue, and an MD repository so your data stays consistent across systems.
We also run a Digital Factory for reusable digital assets, an Innovation Lab to validate ideas, and Legacy Modernization to retire risky apps and replatform where needed.
If you want a clean core with clear steps and best practices, we’ll map your use cases, set API and data contracts, stand up your digital factory, and deliver side-by-side extensions that protect your upgrades — Get Started with eSystems.
FAQ
What is “clean core” in SAP S/4HANA?
It means you leave the standard core unchanged. You use configuration, released APIs, and side-by-side extensions so upgrades stay predictable and costs stay under control.
How do I implement a clean core step by step?
Assess the system, pick greenfield or brownfield, cut custom code, fix master data, standardize integrations, streamline processes, and set governance with clear rules and monitoring.
Greenfield vs brownfield, which is better for a clean core?
Greenfield starts fresh and makes standardization easier. Brownfield keeps what you have, but you must remove old modifications. Choose based on change tolerance, timeline, and risk.
How should I build extensions and APIs to keep the core clean?
Use released APIs and events, build apps side by side, avoid direct database calls, and add contract tests and versioning to catch breaking changes early.
How do MDM and data governance support a clean core after go-live?
They create golden records, set ownership and approval workflow, and synchronize data across systems. You’ll publish master data through APIs and track quality metrics over time.
COMMENTS