SAP Integration

SAP integration that starts with understanding

Connecting SAP to other systems means bridging two worlds — different data models, different expertise, different expectations. It takes someone who understands both sides to design the architecture and build what's missing.

What makes SAP integration hard

These challenges come up in nearly every project.

Two teams, two languages

SAP teams and external system teams work with different data models and terminology. Getting both sides aligned takes deliberate effort.

The scope isn't clear yet

Read or write? Sync or async? UI integration, data replication, or both? These questions shape everything — and they need answers before architecture starts.

A connector is just the beginning

SAP is not just a database — it's a system with business logic, authorization, and transaction semantics. The connector just connects. The integration is everything after.

Production load changes everything

An integration that works in testing can struggle under real traffic. Every user request that triggers an RFC call adds load to SAP.

How these projects succeed

The pattern that works: understand the process, choose the right technology, design for production from day one.

Start with the business process

Map what actually needs to flow between systems before choosing any tool or middleware.

Pick technology that fits the context

RFC, OData, CPI, or custom — depending on what the teams know and what the vendors support.

Design for production from the start

Caching, load management, async patterns. Architecture that holds up under real traffic, not just in demos.

Aligning SAP and external teams

SAP is not a database you query — it has business logic, authorization, and transaction handling that shape every integration decision. Successful projects invest time upfront to build a shared understanding of data models and processes across both teams.

Choosing the right integration path

Not every integration needs SAP Cloud Integration. Sometimes RFC is the right answer — because it's proven, well-supported in S/4HANA, and the integration partner already knows it. The decision depends on the teams, the landscape, and what needs to be maintained long-term.

Handling real production load

A web application that calls RFC on every page view will overload SAP. Production architectures need caching strategies, async replication, and load management from the start.

Integration patterns we work with

Different scenarios need different approaches. We help you pick the one that fits your architecture.

RFC & BAPI Integration

Direct function calls into SAP — the most powerful and most complex integration path. Real-time access to SAP business logic.

Custom RFC function modules
BAPI wrappers for stable APIs
.NET integration via YaNco
Error handling and retry patterns

OData & REST APIs

Modern API layer for SAP data. CDS views, RAP services, or custom OData endpoints — depending on your S/4HANA version and clean core strategy.

CDS-based analytical and transactional APIs
RAP business objects for S/4HANA
Custom OData services for legacy scenarios
API versioning and lifecycle management

SAP Cloud Integration (CPI)

Cloud-based integration flows for hybrid landscapes. Managed middleware when SAP and non-SAP systems need transformation and routing.

Integration Suite iFlow development
Cloud Connector sizing and HA
Event-driven with SAP Event Mesh
Prepackaged and custom integration content

Custom Integration Development

When none of the above fits: purpose-built components in .NET, TypeScript, or ABAP for your specific data model and process flow.

Async replication engines
Message queue and event-based integration
Transformation and mapping logic
Monitoring and operations tooling

Full BTP development capability

Need more than middleware? We also build custom applications on BTP.

CAP Applications

Custom business applications on SAP Cloud Application Programming Model. TypeScript or Java, connected to SAP and non-SAP backends.

Integration Suite Flows

iFlow development for complex transformation and routing. Groovy scripting, custom adapters, and on-premises connectivity via Cloud Connector.

Event-Driven Architecture

SAP Event Mesh, Cloud Events, webhook patterns. Decoupled integration for scenarios where real-time push beats scheduled pull.

What we've built for this

The tools and framework behind our integration projects — open source, production-tested, and available for yours.

Ready-made integration framework

When standard middleware doesn't fit, you don't have to start from scratch. SAPHub is the async integration framework we've built and run in production — available as a foundation you can brand as your own.

SAPHub reference architecture diagram
SAPHub reference architecture — the open source version on GitHub shows the core pattern. Production deployments add workflow orchestration, task management, and transactional RFC.

Interested in a whitelabel solution?

Tell us about your integration requirements and we'll show you how SAPHub can work as a foundation.

We care about your privacy. Read our privacy policy.

SAP RFC on modern .NET — with YaNco

Our integration projects needed an RFC layer that works with modern .NET, supports dependency injection, and runs on Linux. YaNco is that layer — open source and MIT licensed.

  • Open source, MIT licensed
  • Full .NET Core / .NET 6–8+ support
  • Dependency injection and IRfcContext for testability
  • Used in production across customer projects
Learn more
SapIntegration.cs
using Dbosoft.YaNco;

// Register SAP connection via DI
services.AddSingleton(_ =>
    new ConnectionBuilder(sapConfig)
        .ConfigureRuntime(c => c.WithLogger(log))
        .Build());

// Call RFC function (injected context)
var result = await rfcContext
    .CallFunction("BAPI_COMPANYCODE_GETLIST",
      Output: f => f.MapTable(
        "COMPANYCODE_LIST", s =>
        from c in s.GetField<string>("COMP_CODE")
        from n in s.GetField<string>("COMP_NAME")
        select new { Code = c, Name = n }));

No standard solution for your integration?

We've been there. Let's talk about your scenario.