Creating the engine for continuous innovation

By David Lowson

Australia and New Zealand’s geography, sovereign requirements, tightly knit networks and more cautious risk culture call for a deliberately pragmatic approach to SAP transformation. This means protecting the core, pushing innovation to governed extensibility, and using APIs as the controlled “plumbing” for change.

Clean core plus an API‑driven enterprise isn’t a theoretical ideal – it is the most pragmatic path to faster upgrades, lower run costs and sustained agility.

Why clean core + API‑first matters for Australasian organisations

Australasian organisations face a number of factors which shape the practical realities of large-scale transformation – from years of accumulated customisation, scarce architectural talent, lean teams that don’t have the bandwidth to absorb complexity, through to rising cloud costs and the advent and ascent of AI.

To understand why large-scale transformations in Australasia ultimately lose momentum or stall, there is always one culprit: custom code. Decades of bespoke logic create a heavy burden of technical debt – leaving organisations with brittle systems, expensive upgrades, and unable to initiate or adopt innovation quickly.

As SAP continues to evolve towards a predominantly multi-tenant SaaS model – augmented by targeted side-by-side extensions – a clean core becomes essential, allowing organisations to transition to this future architecture with minimal disruption.

A clean core approach provides a practical way forward – reducing technical debt, stabilising the platform and enabling organisations to adopt innovation more quickly and with less risk.

A clean core is the single most powerful lever to reduce cost and accelerate innovation, helping Australasian organisations to:

  • Reduce upgrade risk and cost:
    Stripping bespoke logic out of the core shrinks the regression surface and simplifies upgrades – critical where specialist skills and rapid mobility are constrained.
  • Enable parallel delivery safe from core disruption:
    APIs let multiple teams innovate simultaneously without stepping on each other or endangering production.  
  • Meet sovereign and regulatory needs:
    Governed extensions and clear integration patterns make it easier to prove security and compliance in sovereign cloud deployments.
  • Improve total cost of ownership:
    Less bespoke code, smaller databases and automated testing reduce ongoing run costs. This proves helpful where budgets exist but mobilisation and sustained capability are the limiting factors.
  • Deliver measurable business outcomes faster:
    By moving differentiation out of the core, organisations can deploy faster, test more frequently and show early wins that, in turn, reduce organisational resistance.

What clean core actually means – in plain language

It means:

  • SAP stays standard.
  • Innovation moves outside the core.
  • Differentiation happens through APIs, BTP, microservices and event-driven architectures.
  • Upgrades become fast, predictable and lower risk.
  • Regression testing becomes automated.
  • AI adoption becomes easy, not arduous.

What good looks like

  • A small, well‑governed SAP core with minimal bespoke ABAP: core code is limited to what genuinely must be there.  
  • A documented API catalogue and integration archetypes: sync vs async, event vs batch, UI APIs, and canonical data contracts.  
  • Consistent governance and lifecycle for extensions: discoverability, versioning, security and rollback procedures are enforced.  
  • Automated CI/CD, regression suites and release orchestration: releases are routine, fast and reversible.  
  • Clear separation of responsibilities: product/feature teams innovate in extension layers; platform teams safeguard the core.  
  • Measurable improvements, including shorter upgrade windows, fewer P1 incidents, lower run cost and faster time to benefit.

How to get to clean core and API ‘nirvana’ – a pragmatic roadmap

1. Start with an honest inventory

  • Catalogue custom code, interfaces and technical debt.
  • Classify each item as follows: keep in core, re‑implement as an extension – or retire.
  • Use automated analysis where possible.

2. Define your organisation’s API and integration strategy

  • Create archetypes (synchronous UI APIs, asynchronous event streams, bulk/batch interfaces) and an API gateway pattern.
  • Standardise data contracts and error/retry semantics.

3. Build scaffolding early

  • Put in CI/CD pipelines, automated regression testing, an API gateway, monitoring and rollback tooling before large refactor waves.
  • Sovereign cloud patterns should be validated in a pilot.

4. Prioritise the riskiest and highest‑value customisations

  • Tackle the code that blocks upgrades or causes most incidents first. Early wins demonstrate value and reduce technical risk.

5. Use AI and automation to accelerate refactor

  • Apply code analysis tools and AI to map custom code to standard functionality, suggest refactors and scaffold extensions in your chosen stack (BTP, cloud services). Validate outputs with subject‑matter experts.

6. Implement extensions outside the core

  • Rebuild required differentiation as governed services or apps (BTP, microservices, low‑code where appropriate) with clear APIs back to SAP. Keep core changes minimal and controlled.

7. Enforce strict change gating

  • Treat core changes as exceptional.
  • Route most enhancements through extension lifecycles with automated testing and release pipelines.

8. Modular rollout and rigorous end‑to‑end testing

  • Migrate capability by capability, validating end‑to‑end flows across source systems, middleware and SAP.
  • Use synthetic test data and automated reconciliation to reduce cutover risk.

9. Demonstrate and scale proof points

  • Capture metrics (upgrade time, incident frequency, delivery velocity, run cost) from early projects and publish them internally to build momentum.

10. Embed governance and skills

  • Assign API owners, enforce reuse, and train teams on extension patterns.
  • Invest in local junior talent to sustain capability rather than over‑relying on offshore or aging cohorts.

Concrete benefits to expect

  • Faster, less risky upgrades and fewer emergency fix cycles.  
  • Significant reduction in delivery cycle times for new capabilities (often 50%+ when combined with automation).  
  • Lower run‑cost and lower operational incident rates (practical reductions commonly in the tens of percent).  
  • Higher throughput of business‑facing features without compromising platform stability.  
  • A resilient platform that supports AI/agentic augmentation and sovereign cloud requirements.

A note on approach – pragmatism over perfection

Clean core is a pragmatic aim, not a purity test. In reality, organisations should aim for “clean,” but operate in a “cleaner” state. Standard APIs should be used wherever available or planned by SAP; where they are not, well-structured ABAP remains a pragmatic option.

A perfectly clean core is rarely achievable – the priority is minimising core impact while maintaining flexibility.

Start where your organisation’s pain points and risk factors are greatest, build scaffolding first, use automation to scale the refactor effort, and treat governance as an enabler, rather than a blocker.

Final thoughts

For Australasian organisations, clean core combined with an API‑first enterprise is the most realistic route to rapid, low‑risk SAP modernisation.

It turns regional constraints – such as distance, sovereignty, skills scarcity and cautious adoption – into design advantages: smaller, safer upgrades, faster business value and a platform that enables continuous innovation.

The work to be done is disciplined and pragmatic: inventory the estate, scaffold the platform, extract the bespoke, govern the interfaces – and automate relentlessly.

This is the key to sustainable, affordable, impactful – and right-sized – transformation for Australasian organisations.

What transformation leaders should do now

  • Commit to a cleaner core, not perfection. (90% clean is a win. 100% clean is a myth.)
  • Invest early in API and extensibility patterns.
  • Automate upgrades with testing frameworks and DevOps.
  • Push differentiation outside the SAP core – where innovation belongs
  • Treat architecture as a product, evolving every quarter.