RAISING THE BAR FOR SAP TESTING WITH COMPONENT-BASED AUTOMATION

Testing SAP landscapes has traditionally been complex, slow, and often heavily dependent on manual effort. Large integrated systems make it difficult to isolate changes, test safely, and provide rapid feedback to development teams. As organizations adopt DevOps practices, this challenge becomes even more apparent: teams need faster feedback cycles and greater confidence when deploying changes.

Within Essent’s SAP community, we have been working on a new approach to tackle this challenge. By introducing Component-Based Testing combined with automated test execution and automated test data refresh, we aim to make SAP testing more scalable, reliable, and aligned with the DevOps way of working.

Our goal is simple: enable teams to take ownership of quality at the component level while providing automated feedback as early as possible.

From monolithic testing to component ownership

Our SAP landscape is structured around bounded contexts, each containing one or more components. A component represents a logical piece of functionality and is owned by a single DevOps team.

Instead of testing large end-to-end processes that span multiple teams, we focus on component-level regression tests. Each component has its own automated test set that validates its key functionality. On average, each component contains around eight automated regression tests.

This structure provides several benefits:

• Clear ownership: every component and its tests are maintained by the responsible team.
• Faster feedback: teams can validate their own functionality independently.
• Reduced coordination overhead between teams.

By aligning tests with the same boundaries as the teams that build the software, testing becomes a natural part of the development workflow rather than a centralised activity.

Automating SAP GUI and Fiori testing with Tosca

To implement component-based testing effectively, automation is essential.

Within our SAP community we use Tricentis Tosca to automate tests for both SAP GUI and SAP Fiori applications. Tosca allows us to model and automate functional test cases in a maintainable way, while supporting the complex UI structures often found in SAP systems.

Each component has its own set of Tosca test cases that validate the critical functionality of that component. These automated tests act as component regression tests, ensuring that key behavior remains intact when changes are introduced.

By focusing on component-level automation, we avoid creating large and brittle end-to-end test suites. Instead, we build smaller, targeted tests that are easier to maintain and quicker to execute.

Reliable test data with automated refresh

One of the biggest challenges in SAP testing is test data management. Tests are only reliable if they run on consistent and predictable data.

To address this, we use Qlik Gold Client to automate test data refreshes. Before running a component test set, the required data is refreshed as part of the test execution process.

This ensures that every test run starts with clean, known data conditions.

Automating test data refresh provides several advantages:

• Consistent test environments
• Reduced manual preparation
• More reliable and repeatable tests

Instead of relying on manually prepared datasets, teams can trigger test runs that automatically prepare the required data before executing the tests.

Running tests with GitLab and GitLab Runners

Automation is orchestrated using GitLab and GitLab Runners.

When a component test run is triggered, GitLab starts a pipeline that executes the automated tests using available runners. As part of the process:

• The required test data is refreshed using Gold Client.
• The Tosca tests for the component are executed.
• Results are collected and reported.

Initially, these tests are primarily used for automated regression validation. Over time, the goal is to integrate them further into delivery pipelines, allowing teams to validate their changes automatically before deploying to shared environments.

This approach brings SAP testing closer to modern DevOps practices where automation and continuous feedback play a central role.

Enabling teams to mature in testing

The ultimate goal of this initiative is not just automation—it is helping teams raise their testing maturity.

Component-based testing provides a clear framework that encourages teams to:

• define critical regression scenarios
• maintain automated validation for their functionality
• take ownership of quality

At the same time, automation reduces the overhead traditionally associated with SAP testing. Automated execution, automated test data refresh, and clear ownership boundaries make testing more manageable and scalable.

As more components adopt automated regression tests, the SAP community as a whole gains greater confidence in system stability and changes.

Looking ahead

Our current focus is on establishing reliable automated regression tests per component and helping teams adopt the component-based testing approach. As more teams start working with this model, we expect the SAP testing landscape to gradually evolve from centralized testing towards team-owned quality validation.

For 2026, we have defined several high-level next steps to further mature this approach across the SAP community.

A key objective is that each DevOps team identifies at least one SAP component and implements Component-Based Testing (CBT) for it. This means that the component has a defined regression test set, automated test execution, and the ability to run these tests independently.

Teams will also further integrate the supporting tooling used within this approach, including:

• GitLab for orchestrating test runs and pipelines
• Tosca for automated SAP GUI and Fiori testing
• Postman collections for API-level validation where applicable

By combining these tools with automated test data refresh using Gold Client, teams will be able to trigger reliable regression validation whenever needed.

We are already seeing encouraging progress. Budget Billing and SAP Maximizers have completed the first steps of this journey, identifying their component boundaries and implementing the initial automated regression tests. The Billioners already started with the discovery phase and are ready to take the next steps.

These early adopters provide valuable insights and help demonstrate how component-based testing can work in practice within our SAP landscape.

As more teams adopt this approach, the goal is to gradually integrate these automated tests into delivery pipelines, enabling faster feedback and greater confidence when deploying changes.

When teams own their components, they should also own the confidence to change them. Component-Based Testing helps make that confidence measurable, repeatable, and automated.