The integration platform and clean core: a target architecture for a hybrid landscape

#The 60-second version

Every company that runs SAP connects it to other systems: a CRM, a warehouse, the shop floor, banks, customers, carriers. There are two ways to do that.

• Point to point. Each pair of systems is wired together directly, often with custom code inside the ERP that reads its tables and writes files. It is fast to build the first time. Every later change is slow, because the logic is scattered and nobody watches all the wires.
• Through a platform. The ERP talks only through interfaces SAP has released and promises to keep stable. A separate integration platform does the translating, routing, partner handling and monitoring. SAP's platform for this is SAP Integration Suite.

Clean core is SAP's name for keeping the ERP close to standard, so upgrades are cheap and safe. It covers interfaces too: an interface built on custom code inside the ERP is a piece of the core that breaks at upgrades.

The decision for a leader is not "buy a platform or not". It is which interfaces move, in what order, which stay as they are, and who owns the result. This topic gives you that decision, using Calder Pumpworks, the fictional pump maker used across this course.

#Why it matters to the business

Point-to-point integration rarely fails on day one. It gets expensive later, in four ways:

• Changes ripple into the ERP. At Calder, the CRM gets order status from a nightly file written by a custom report inside S/4HANA. When Calder replaces its CRM, that report changes too: a transport, a test cycle and a release slot in the ERP, for a change that had nothing to do with the ERP.
• Upgrades cost more. Custom code that reads SAP's internal tables can break when SAP changes them. SAP guarantees the stability of released interfaces from release to release, and expects customers to build on them in return (SAP Learning). Every interface off that path is retested at every upgrade.
• Nobody sees failures. A file that didn't arrive looks exactly like a quiet night. Without central monitoring, the business finds out from a customer.
• The rules are tightening. As of SAP's API policy webinar on 30 June 2026, published APIs used as documented are the supported path and undocumented interfaces are used at the customer's own risk. One interface, ODP-RFC extraction, has been technically blocked since 9 June 2026, with a temporary opt-out until 31 December 2026 (ASUG, July 2026). Calder's data warehouse uses it today.

A useful way to explain this to a steering committee: with 6 systems that all talk to each other, there can be up to 15 separate links; with 12 systems, up to 66. A platform doesn't always reduce the number of wires. At Calder it adds a few. What it changes is where the logic lives (outside the ERP), who watches (one team, one monitor) and what a change touches (one flow, not the ERP).

#How SAP does it

As of October 2026, from SAP pages opened for this topic:

• SAP Integration Suite is SAP's integration platform on SAP Business Technology Platform (BTP). Its features page lists Cloud Integration (building and running integration flows, with over 3,200 prebuilt integrations), API Management (publishing and protecting APIs, with over 40 built-in policies), Open Connectors for third-party applications, Integration Advisor and Trading Partner Management for business-to-business (B2B) messages, Integration Assessment, Edge Integration Cell, an event-driven architecture service and a migration assessment (SAP).
• Events run through SAP Integration Suite, advanced event mesh, or the smaller Event Mesh capability, covered in how SAP systems talk.
• Editions differ by country page. SAP's US pricing page listed starter, standard and premium editions; the starter edition allows 10 custom integration flows per global account (SAP US). SAP's German page listed a starter and an enhanced edition, the latter with an advanced event mesh tenant and AI features "under fair use waiver until September 2026" (SAP Germany). Your contract decides what you have.
• SAP Business Accelerator Hub (api.sap.com) is the catalog of what SAP has released: APIs, events, CDS views and extension points (SAP Learning). If an interface you want isn't there, that is a design finding, not a detail.
• Clean core for integrations. SAP's training asks for released APIs without modification, standard integrations where they exist, event-driven designs for decoupling, central monitoring, and SAP's Integration Solution Advisory Methodology (ISA-M) to get transparency over today's interfaces and their technical debt (SAP Learning).
• SAP Process Orchestration (PI/PO), SAP's older on-premise middleware, reaches the end of standard maintenance in 2027, with extended maintenance possible until 2030, according to a customer reference architecture in SAP's Architecture Center (SAP Architecture Center).

#Platform or point to point: a guide for each interface

Not every interface belongs on the platform. Ask these questions per interface, in this order:

Two rules sit on top. Every interface, direct or not, is on one inventory with an owner and a monitor. And nothing new is built on custom code inside the ERP without an architecture decision.

#Questions to ask

1. Which of our interfaces run on custom code inside the ERP, and what does each cost us at an upgrade?
2. Do any of our interfaces or extractions use something SAP hasn't published, such as ODP-RFC? What is the plan before 31 December 2026?
3. Which edition of Integration Suite are we licensed for, and does it include the features this design needs (events, Edge Integration Cell, B2B, the MCP gateway for agents)?
4. Which interfaces will we leave alone, and why?
5. Who owns a failed message at two in the morning: IT, or the business team that understands the order?
6. If we run PI/PO today, what is our migration date, and which interfaces retire instead of moving?
7. Where must data stay on site, and does that call for Edge Integration Cell?

#Common misconceptions

• "A platform reduces the number of connections." Sometimes. If most systems talk only to the ERP, a hub can add links. The gain is where the logic lives and who watches it.
• "Clean core means no IDocs." SAP's own training says IDocs may still be the right choice in some situations. The problem is custom code in the core, not old formats.
• "Everything must go through Integration Suite." SAP-delivered integrations between SAP products, and analytics extractions, usually have their own path.
• "Migrate every PI/PO interface one to one." Some should retire, some should be redesigned on released APIs. Moving them unchanged moves the debt.
• "Released means we never look at it again." Released means SAP keeps it stable from release to release. You still check its state on the Business Accelerator Hub for deprecations and successors.

#Key terms

All course terms, A to Z, in the glossary

• Point-to-point integration: two systems wired directly, each pair built and run separately.
• Integration platform (iPaaS): a cloud service that translates, routes and monitors messages between systems.
• SAP Integration Suite: SAP's integration platform on SAP BTP.
• Released API: an interface SAP publishes and keeps stable across releases.
• SAP Business Accelerator Hub: SAP's catalog of released APIs, events and other objects.
• Clean core: keeping the ERP close to standard so upgrades are cheap and safe; it covers interfaces as well as extensions.
• Edge Integration Cell: a runtime of Integration Suite that runs in your own environment while flows are designed in the cloud.
• ISA-M: SAP's Integration Solution Advisory Methodology, a way to classify interfaces and choose technology.
• Architecture decision record (ADR): a short record of one decision: context, options, decision, consequences.

#Check yourself

#Mental model

Draw three rings.

• The core is S/4HANA. It talks to the outside only through interfaces SAP has released: OData and SOAP APIs, business events, IDocs and the classic interfaces SAP documents, and SAP's own standard integrations. Nothing in the core knows who the CRM is.
• The platform sits around it. It owns everything that changes with the outside world: mappings, routing, partner agreements, protocols, retries, security policies and monitoring.
• The edges are everything else: the CRM, the shop floor, banks, carriers, distributors, agents. They change on their own schedule.

A change at an edge should stop at the platform. A change in the core (an upgrade) should be absorbed by SAP's stability promise on released interfaces. Every interface that breaks this picture, custom code in the core, an unpermitted interface, a direct table read, is a place where an edge change or an upgrade costs money.

The second idea: the platform is not the goal. Some interfaces are best left direct (SAP-to-SAP standard integrations), some go another way (analytics extraction) and some should simply retire. The target architecture is a decision per interface.

#How it works

#What the platform does, capability by capability

As of October 2026, SAP's features page lists these capabilities in SAP Integration Suite (SAP):

What is in your tenant depends on the edition. SAP's US pricing page (opened 30 October 2026) listed:

• starter: 10 custom integration flows per global account and adapters such as HTTP, SOAP, OData, SFTP, IDoc and RFC;
• standard: adds API lifecycle management, B2B libraries, third-party connectors, asynchronous message queues and business event publishing;
• premium: adds Edge Integration Cell tenants and more messages (SAP US).

The German page listed an enhanced edition instead, with an advanced event mesh tenant and AI features for integration developers (SAP Germany). ASUG's July 2026 summary of SAP's API policy places the MCP gateway for agents in the Enhanced and Premium editions (ASUG). Names and contents differ between SAP's country pages; read your own contract.

#The Business Accelerator Hub as the contract list

The SAP Business Accelerator Hub lists remote APIs, events, CDS views, RAP business object interfaces and BAdIs. SAP's training states the deal behind it: SAP guarantees the stability of released interfaces from release to release, and customers agree to use only those in new developments (SAP Learning).

For an integration architect, the Hub answers three questions per interface:

1. Is there a released API or event for this object and direction? If not, the design needs a decision: a classic interface (IDoc, BAPI), a custom API built with ABAP Cloud on released objects, or a process change.
2. Which edition and version? An API listed for S/4HANA Cloud Public Edition may not exist in the same form in private edition or on premise. Check the product filter.
3. What is its state? Watch for deprecation and named successors, and plan the move before the old one goes.

#Clean core, applied to interfaces

SAP's clean core training for integrations asks for released APIs without modification, standard integrations where SAP delivers them, no transactional interfaces used for mass replication, event-driven designs to decouple systems, central end-to-end monitoring, and ISA-M to make today's interfaces and their debt visible. It also says IDocs may still be recommended in some situations (SAP Learning).

SAP defines levels A to D for extensions, covered in fit-to-standard and extension choices. This course borrows the letters to rate the SAP end of an interface. That is a course simplification, not an SAP rating:

The rating is about the SAP end. A flow in Integration Suite that calls a released API rates A; the same flow calling a custom RFC module that reads order tables rates C. The platform does not clean an interface by itself.

#Hybrid landscapes: reaching what isn't in the cloud

Calder's landscape is hybrid: CP10 on S/4HANA Cloud Private Edition under RISE, CP20 on ECC on premise until July 2027, an MES at the Rockford plant, and cloud applications for HR and CRM (landscape and deployment options). Two SAP pieces matter:

• Cloud Connector runs as an agent inside the customer's network and acts as a reverse invoke proxy between that network and SAP BTP, with fine-grained control over which systems and resources cloud applications may reach (SAP Learning). A cloud flow reaches the Rockford MES this way.
• Edge Integration Cell runs integration flows on a Kubernetes cluster the customer manages (on a hyperscaler or on premise), while flows are designed and managed in SAP BTP. SAP's reference architecture names data residency, PI/PO modernization and latency as reasons, and warns that stored JMS messages can be lost when a cluster is rebuilt, so plan replay and reconciliation (SAP Architecture Center).

flowchart LR
  subgraph cloud[SAP BTP]
    IS[Integration Suite<br/>design and cloud runtime]
    EM[(Event broker)]
  end
  subgraph rise[RISE private cloud]
    S4[S/4HANA CP10]
  end
  subgraph plant[Rockford plant network]
    CC[Cloud Connector]
    MES[MES]
    EIC[Edge Integration Cell<br/>option]
  end
  S4 <-->|released APIs, IDocs| IS
  S4 -->|events| EM
  IS <-->|tunnel| CC --> MES
  IS -.->|deploy flows| EIC -.-> MES

#Why point to point costs what it costs

Four costs make up the bill, and only the first is visible in a project plan:

1. Build. Usually cheaper point to point. This is why it keeps happening.
2. Change. When a partner changes, point-to-point logic changes wherever it lives. If it lives in the ERP, that is an ERP release.
3. Upgrade. Every interface rated C or D is retested at each upgrade, and some are rebuilt.
4. Operations. Each separately built interface has its own logs, alerts (or none) and its own expert.

The worst case grows fast: n systems that all talk to each other can need n(n-1)/2 links. Real landscapes are usually closer to a star around the ERP, which is why the case for a platform rests on costs 2 to 4, not on counting wires. The script below shows both.

#Build it yourself: Calder's target integration architecture

You will describe Calder's twelve interfaces as they run today and as a target design, compare the two in numbers, test what a CRM replacement would touch, and generate the target diagram and a draft architecture decision record. One script does all of it.

flowchart LR
  INV[Interface list<br/>today and target] --> CMP[compare]
  INV --> WI[what-if crm]
  INV --> DG[diagram: .mmd]
  INV --> ADR[adr: .md]

Before you start: complete Set up your computer for this course and Set up for Unit 5B. You need the orchestrate-course folder with its .venv and a unit5b folder. This topic installs no libraries.

#What you need

• Your course folder and the unit5b folder.
• Python 3.10 or later. No accounts, no internet, no cost.
• About 30 minutes.

All interfaces, technologies, ratings and costs are fictional Calder course values. Interface IDs I01 to I12 come from the exception trace and how SAP systems talk. Retest days by rating (A 0.5, B 1.5, C 4, D 8) and the 900 USD day rate are the same course inputs as in the fit-to-standard topic.

#Step 1: Open the course folder and turn on the virtual environment

1. Open VS Code, choose File > Open Folder and open orchestrate-course.
2. Open a terminal with Terminal > New Terminal.
3. Turn on the virtual environment if the prompt doesn't start with (.venv):

   • Windows (PowerShell):

     Copy

     .venv\Scripts\Activate.ps1

   • macOS / Linux:

     Copy

     source .venv/bin/activate

#Step 2: Create the script

1. Create a new file, paste the script below, and save it as target_architecture.py inside unit5b.

"""Calder's integration landscape today and as a target design (Unit 5B).

Calder Pumpworks is a fictional company. Interface IDs reuse the earlier
Unit 5B topics. Technologies, ratings, retest days and the day rate are
course values, written to teach the decision, not SAP figures.

  python unit5b/target_architecture.py compare           today vs target, in numbers
  python unit5b/target_architecture.py what-if crm       what a CRM replacement touches
  python unit5b/target_architecture.py diagram           write unit5b/calder_target.mmd
  python unit5b/target_architecture.py adr               write unit5b/adr-001-integration-platform.md
  python unit5b/target_architecture.py links 6           point-to-point links for 6 systems

Only Python's standard library is used. Nothing goes over the internet.
"""
import argparse
import sys
from pathlib import Path

# Course rating for the SAP end of an interface, borrowed from SAP's clean
# core levels for extensions (see the fit-to-standard topic). Applying the
# letters to interfaces is a course simplification.
#   A  released API or event, or an SAP-delivered integration
#   B  classic interface SAP documents: IDoc, BAPI, standard replication
#   C  custom code reading SAP's internal tables, or an unpermitted interface
#   D  custom code writing SAP's tables directly
#   M  manual: email, portal, spreadsheet (no interface at all)
RETEST_DAYS = {"A": 0.5, "B": 1.5, "C": 4.0, "D": 8.0, "M": 0.0}   # per upgrade
DAY_RATE_USD = 900          # course value, same as the fit-to-standard topic
UPGRADES_PER_YEAR = 1       # course value
YEARS = 5

HUB = "Integration Suite"    # Calder's target platform (cloud integration, TPM)
EVENTS = "Event broker"      # advanced event mesh in the target design

# id, partner system, what flows,
#   today:  (route, technology, rating, monitored centrally?)
#   target: (route, technology, rating, monitored centrally?)
# route "direct" = point to point; HUB or EVENTS = through the platform;
# "retire" = the interface disappears in the target design.
INTERFACES = [
    ("I01", "SAP Business Network", "POs, confirmations, ship notices",
     ("direct", "SAP-delivered network integration", "A", True),
     ("direct", "SAP-delivered network integration (unchanged)", "A", True)),
    ("I02", "MES Rockford", "Released orders out, confirmations back",
     ("direct", "Custom RFC module reading order tables; file back", "C", False),
     (HUB, "Released production order API; MES via Cloud Connector", "A", True)),
    ("I03", "CRM", "Sales order status and confirmed dates",
     ("direct", "Nightly CSV from a custom report", "C", False),
     (EVENTS, "Sales order events; CRM reads the order by released API", "A", True)),
    ("I04", "Customers", "Changed order confirmations",
     ("direct", "Standard output management, email PDF", "A", True),
     ("direct", "Standard output management (unchanged)", "A", True)),
    ("I05", "EWM RKDC", "Deliveries out, goods issue back",
     ("direct", "Standard delivery replication (queued RFC)", "B", True),
     ("direct", "Standard delivery replication (unchanged)", "B", True)),
    ("I06", "Carriers", "Freight orders, tenders, invoices",
     ("direct", "Email and carrier portals, keyed by hand", "M", False),
     (HUB, "B2B flows with Trading Partner Management", "A", True)),
    ("I07", "Data warehouse", "Open orders and billing",
     ("direct", "ODP-RFC extraction", "C", False),
     ("direct", "CDS extraction to Datasphere", "A", True)),
    ("I08", "Bank", "Bank statements",
     ("direct", "Bank file to SFTP, standard upload", "B", False),
     ("direct", "SAP Multi-Bank Connectivity", "A", True)),
    ("I09", "Agent on BTP", "Exception events, read-only APIs",
     ("new", "Not built yet", "-", False),
     (EVENTS, "Business events plus released read APIs", "A", True)),
    ("I10", "Distributors", "Customer purchase orders by EDI",
     ("direct", "EDI provider maps to IDoc ORDERS", "B", False),
     (HUB, "Trading Partner Management to IDoc ORDERS", "B", True)),
    ("I11", "ECC CP20", "Intercompany orders and invoices",
     ("direct", "IDoc-based EDI between the systems", "B", False),
     ("retire", "Gone after the July 2027 rollout; stays direct until then", "-", False)),
    ("I12", "CRM", "Availability check while quoting (2 s)",
     ("direct", "Custom OData service on custom code", "C", False),
     (HUB, "Released API behind API Management", "A", True)),
]

CORE = "S/4HANA CP10"


def rows(design):
    """Yield (id, partner, route, technology, rating, monitored) for one design."""
    for iid, partner, _what, today, target in INTERFACES:
        route, tech, rating, monitored = today if design == "today" else target
        yield iid, partner, route, tech, rating, monitored


def connections(design):
    """Count the physical connections that someone must build and run."""
    links = set()
    for _iid, partner, route, _t, _r, _m in rows(design):
        if route in ("new", "retire"):
            continue
        if route == "direct":
            links.add(frozenset((CORE, partner)))
        else:                                  # through the platform
            links.add(frozenset((CORE, route)))
            links.add(frozenset((route, partner)))
    return links


def summary(design):
    live = [r for r in rows(design) if r[2] not in ("new", "retire")]
    ratings = {k: sum(1 for r in live if r[4] == k) for k in "ABCDM"}
    retest = sum(RETEST_DAYS[r[4]] for r in live)
    return {
        "interfaces running": len(live),
        "connections to build and run": len(connections(design)),
        "rated A": ratings["A"], "rated B": ratings["B"],
        "rated C or D": ratings["C"] + ratings["D"], "manual": ratings["M"],
        "monitored centrally": sum(1 for r in live if r[5]),
        "retest days per upgrade": retest,
        f"retest cost over {YEARS} years (USD)": retest * DAY_RATE_USD * UPGRADES_PER_YEAR * YEARS,
    }


def cmd_compare(_args):
    today, target = summary("today"), summary("target")
    print(f"{'Measure':40} {'Today':>10} {'Target':>10}")
    for key in today:
        a, b = today[key], target[key]
        fmt = (lambda v: f"{v:,.0f}") if "USD" in key else (lambda v: f"{v:g}")
        print(f"{key:40} {fmt(a):>10} {fmt(b):>10}")
    print("\nInterfaces that still need work in the target design:")
    found = False
    for iid, partner, route, tech, rating, monitored in rows("target"):
        if route == "retire":
            continue
        problems = []
        if rating in ("C", "D", "M"):
            problems.append(f"rated {rating}")
        if not monitored:
            problems.append("no central monitoring")
        if problems:
            found = True
            print(f"  {iid} {partner}: {', '.join(problems)}")
    if not found:
        print("  none")


def cmd_what_if(args):
    partner = {"crm": "CRM", "mes": "MES Rockford", "bank": "Bank"}[args.system]
    print(f"Replacing the {partner}: what has to change?\n")
    for design in ("today", "target"):
        print(f"{design.upper()}")
        for iid, p, route, tech, rating, _m in rows(design):
            if p != partner or route in ("new", "retire"):
                continue
            inside_core = rating in ("C", "D")
            where = "custom code inside S/4HANA (transport, retest)" if inside_core \
                else f"the {route if route != 'direct' else 'connection'} only; S/4HANA untouched"
            print(f"  {iid} {tech}\n      change: {where}")
        print()


def cmd_diagram(_args):
    lines = ["flowchart LR", f"  S4[{CORE}]", f"  HUB[{HUB}<br/>cloud integration, TPM, API Mgmt]",
             f"  EVB[({EVENTS}<br/>advanced event mesh)]",
             "  S4 <-->|released APIs, IDocs| HUB", "  S4 -->|business events| EVB"]
    names = {}
    for iid, partner, route, tech, _r, _m in rows("target"):
        if route == "retire":
            continue
        node = names.setdefault(partner, f"P{len(names) + 1}")
        lines.append(f"  {node}[{partner}]")
        src = {"direct": "S4", HUB: "HUB", EVENTS: "EVB"}[route]
        lines.append(f"  {src} ---|{iid}| {node}")
    out = Path("unit5b") / "calder_target.mmd"
    out.parent.mkdir(exist_ok=True)
    out.write_text("\n".join(dict.fromkeys(lines)) + "\n", encoding="utf-8")
    print(f"Wrote {out} ({len(lines)} lines). Paste it into a mermaid viewer to see it.")


def cmd_adr(_args):
    t, g = summary("today"), summary("target")
    text = f"""# ADR-001: Integration platform for Calder's landscape

Status: proposed
Date: 2026-10-30

## Context
{t['interfaces running']} interfaces run point to point from {CORE}, {t['rated C or D']} of them on
custom code that reads SAP's internal objects or on an unpermitted interface,
and {t['interfaces running'] - t['monitored centrally']} with no central monitoring.
CP20 joins CP10's system in July 2027. Partners, a new agent and the CRM will keep changing.

## Options
A. Keep point to point and fix interfaces one by one.
B. SAP Integration Suite as the hub (cloud integration, Trading Partner Management,
   API Management) plus an event broker; SAP-to-SAP standard integrations stay direct.
C. A non-SAP integration platform as the hub.
D. Option B, with Edge Integration Cell at Rockford for plant traffic.

## Decision
B. Revisit D if plant traffic must stay on site or the cloud round trip misses the MES target.

## Consequences
- Connections to build and run: {t['connections to build and run']} today, {g['connections to build and run']} in the target.
- Interfaces rated C or D: {t['rated C or D']} today, {g['rated C or D']} in the target.
- Retest days per upgrade: {t['retest days per upgrade']:g} today, {g['retest days per upgrade']:g} in the target (course values).
- Calder pays a platform subscription and needs an integration team that owns monitoring.
- I11 is not moved: it stays direct until the rollout, then disappears.
"""
    out = Path("unit5b") / "adr-001-integration-platform.md"
    out.parent.mkdir(exist_ok=True)
    out.write_text(text, encoding="utf-8")
    print(f"Wrote {out}")


def cmd_links(args):
    n = args.systems
    if n < 2:
        sys.exit("give at least 2 systems")
    print(f"{n} systems: up to {n * (n - 1) // 2} point-to-point links, "
          f"or {n} links to one hub.")


def main():
    p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    sub = p.add_subparsers(dest="cmd", required=True)
    sub.add_parser("compare").set_defaults(fn=cmd_compare)
    w = sub.add_parser("what-if")
    w.add_argument("system", choices=["crm", "mes", "bank"])
    w.set_defaults(fn=cmd_what_if)
    sub.add_parser("diagram").set_defaults(fn=cmd_diagram)
    sub.add_parser("adr").set_defaults(fn=cmd_adr)
    l = sub.add_parser("links")
    l.add_argument("systems", type=int)
    l.set_defaults(fn=cmd_links)
    a = p.parse_args()
    a.fn(a)


if __name__ == "__main__":
    main()

#Step 3: Compare today with the target

1. Run:

   Copy

   python unit5b/target_architecture.py compare

   On Windows, the same command works in PowerShell.

2. You should see:

   Copy

   Measure                                       Today     Target
   interfaces running                               11         11
   connections to build and run                     10         13
   rated A                                           2          9
   rated B                                           4          2
   rated C or D                                      4          0
   manual                                            1          0
   monitored centrally                               3         11
   retest days per upgrade                          23        7.5
   retest cost over 5 years (USD)              103,500     33,750
   
   Interfaces that still need work in the target design:
     none

Read it in this order:

• Connections go up, from 10 to 13. Calder's systems mostly talk only to S/4HANA, so adding a platform and a broker adds links. If someone sells you a platform on wire count alone, ask for this table.
• Interfaces rated C or D go from 4 to 0, and central monitoring from 3 to 11. This is where the case is.
• Retest days per upgrade fall from 23 to 7.5. Over five years at one upgrade a year, that is the difference between the two cost lines.

#Step 4: Ask what a CRM replacement touches

1. Run:

   Copy

   python unit5b/target_architecture.py what-if crm

2. You should see:

   Copy

   Replacing the CRM: what has to change?
   
   TODAY
     I03 Nightly CSV from a custom report
         change: custom code inside S/4HANA (transport, retest)
     I12 Custom OData service on custom code
         change: custom code inside S/4HANA (transport, retest)
   
   TARGET
     I03 Sales order events; CRM reads the order by released API
         change: the Event broker only; S/4HANA untouched
     I12 Released API behind API Management
         change: the Integration Suite only; S/4HANA untouched

Today, both CRM interfaces live in custom code inside S/4HANA, so a CRM project becomes an ERP project. In the target, the event subscription and the API proxy change; the ERP doesn't. Try what-if mes and what-if bank too.

#Step 5: See how fast point to point can grow

1. Run:

   Copy

   python unit5b/target_architecture.py links 6
   python unit5b/target_architecture.py links 12

2. You should see:

   Copy

   6 systems: up to 15 point-to-point links, or 6 links to one hub.
   12 systems: up to 66 point-to-point links, or 12 links to one hub.

That is the worst case, where every system talks to every other. Step 3 showed the real case at Calder. Use both when you explain the choice.

#Step 6: Generate the diagram and the decision record

1. Run:

   Copy

   python unit5b/target_architecture.py diagram
   python unit5b/target_architecture.py adr

2. You should see:

   Copy

   Wrote unit5b/calder_target.mmd (28 lines). Paste it into a mermaid viewer to see it.
   Wrote unit5b/adr-001-integration-platform.md

   On Windows the paths print with \ instead of /.

3. Open unit5b/calder_target.mmd, copy its text, and paste it into the Mermaid Live Editor at https://mermaid.live to see the picture. It starts like this:

   Copy

   flowchart LR
     S4[S/4HANA CP10]
     HUB[Integration Suite<br/>cloud integration, TPM, API Mgmt]
     EVB[(Event broker<br/>advanced event mesh)]
     S4 <-->|released APIs, IDocs| HUB
     S4 -->|business events| EVB
     P1[SAP Business Network]
     S4 ---|I01| P1

4. Open unit5b/adr-001-integration-platform.md. It holds context, four options, a decision and consequences, with the numbers from Step 3 filled in. Its status is proposed: a person changes it to accepted after review.

5. Save your work with Git:

   Copy

   git add unit5b/target_architecture.py unit5b/calder_target.mmd unit5b/adr-001-integration-platform.md
   git commit -m "Unit 5B: Calder target integration architecture and ADR"

#What the code does

#If something goes wrong

#The SAP way

Licensing: Integration Suite, advanced event mesh and Edge Integration Cell are subscriptions with included message volumes. SAP's US page lists test, demo and development editions for partners only. We found no free tier for customers on the pricing pages opened for this topic; the Unit 5B setup covers what you can try. This topic's code needs none of it.

#Build vs. SAP

#Architecture view

Where it sits. The target diagram from Step 6, drawn by hand:

flowchart LR
  S4[S/4HANA CP10] <-->|released APIs, IDocs| HUB[Integration Suite]
  S4 -->|events| EVB[(Advanced event mesh)]
  HUB --- MES[MES Rockford]
  HUB --- CAR[Carriers]
  HUB --- DIS[Distributors EDI]
  HUB --- CRM[CRM]
  EVB --- CRM
  EVB --- AG[Agent on BTP]
  S4 --- BN[SAP Business Network]
  S4 --- EWM[EWM RKDC]
  S4 --- BANK[Bank via Multi-Bank Connectivity]
  S4 --- DW[Datasphere]
  S4 -. until July 2027 .- ECC[ECC CP20]

Non-functional requirements that decide the design.

Integration and identity. System-to-system flows use technical users, one per communication arrangement, with only the APIs that flow needs (calling your first SAP API). Credentials live in the platform's secure store, never in a flow (secrets and OAuth). Cloud Connector exposes only the MES resources the flow calls. An agent that acts for a person carries that person's identity, so SAP authorizations apply (grounding with authorizations).

The decision to record.

• Context: 11 interfaces run point to point from CP10, 4 on custom code or an unpermitted interface, 8 without central monitoring; CP20 joins in July 2027; the CRM and an agent will change.
• Options: A, keep point to point; B, Integration Suite as hub with an event broker, SAP-to-SAP standard integrations direct; C, a non-SAP iPaaS; D, B plus Edge Integration Cell at Rockford.
• Decision: B. Revisit D if plant traffic must stay on site or the MES latency target is missed.
• Consequences: no interface rated C or D, one monitor, a subscription and a small integration team; I11 retires instead of moving; Calder depends on its edition including events and B2B.

What a design review will ask.

1. Which interfaces stay direct, and why is each one acceptable?
2. Is every SAP end on a released API, event or documented classic interface, checked on the Business Accelerator Hub for our edition?
3. Does our licensed edition include what the design uses: events, Trading Partner Management, Edge Integration Cell?
4. Who owns each interface's failures, and where do they see them?
5. What is the replacement for ODP-RFC, and is it live before 31 December 2026?

#Production concerns

• Security. Least privilege per technical user and per Cloud Connector resource. API Management policies (keys, rate limits) in front of anything outsiders call. Review who can deploy flows: a flow can move any data its credentials allow.
• SAP authorizations. Communication arrangements decide what each technical user may call. Don't share one user across flows; an audit can't tell them apart. See roles and authorization design.
• Evaluation. Measure the platform by the numbers in Step 3 on real data: interfaces by rating, monitored share, mean time to detect a failure, and change lead time for a partner change.
• Cost. Message volumes drive the subscription. Count month-end peaks, retries and events per order before choosing an edition.
• Operations. One inventory, one monitor, named owners, runbooks for reprocessing. Plan replay for queues, especially on Edge Integration Cell, where SAP warns stored messages can be lost when a cluster is rebuilt.
• Clean core. Add an ATC or design-review gate: no new interface on custom code that reads SAP's internal tables without an ADR. "Get clean, stay clean" is SAP's phrase for exactly this.

#Pitfalls

• Selling the platform on wire count. At a star-shaped landscape like Calder's, a hub adds links. Make the case on change, upgrade and operations costs.
• Lift and shift from PI/PO. Moving custom RFC calls into Cloud Integration unchanged keeps them rated C. Redesign the SAP end.
• Migrating interfaces that are about to retire. Check the program plan before moving anything.
• Routing SAP's standard integrations through your hub. You take over support for something SAP already runs and tests.
• Ignoring the edition. A design that assumes events or Edge Integration Cell on an edition without them fails at contract time.
• Platform without owners. A central monitor nobody reads is a slower way to find out from customers.
• Using a transactional API for mass replication. SAP's clean core training says not to; use the replication or extraction path meant for volume.

#Exercise: add the HR interface to the target

Calder's cost center feed to SAP SuccessFactors Employee Central stopped on 14 September 2026, and a new hire was rejected because HR still had a closed cost center (hire-to-retire). Add that interface to the design.

Before you start: have target_architecture.py from this topic saved and working.

1. Open unit5b/target_architecture.py in VS Code.
2. Add a row to INTERFACES for I13: partner SuccessFactors EC, content Cost centers out, employees back.
3. For today, use route "direct", technology "Monthly cost center file, started by hand", rating "M" and False for monitoring.
4. For the target, read the hire-to-retire topic on how SAP integrates Employee Central with S/4HANA, then choose a route ("direct", HUB or EVENTS), a technology and a rating. Search the Business Accelerator Hub for the integration you name, and write in a comment which page you found.
5. Run python unit5b/target_architecture.py compare and check I13 doesn't appear under "still need work".
6. Run diagram and adr again and check I13 and the new numbers appear in both files.
7. In the ADR's Consequences, add one line on what changes for the HR integration team.
8. Commit with Git.

Done when: compare lists 12 running interfaces in both columns and nothing under "still need work", the diagram shows I13, and your ADR names the SAP source for the I13 design. The inventory and ADR feed the integration lead's toolkit.

#Check yourself