IBM: Interview With SAP Enterprise Commerce Architect Aparna Krishna Penumatcha About AI, Digital Transformation, And Enterprise Commerce Architecture

SAP Commerce Cloud is an enterprise e-commerce platform that helps businesses manage digital storefronts, customer experiences, product catalogs, and complex B2B and B2C transactions. Pulse 2.0 interviewed IBM Enterprise Commerce Architect and SAP Commerce Cloud Consultant Aparna Krishna Penumatcha to learn more about her 18-year career at the company, enterprise digital transformation strategies, cloud-native commerce architecture, AI-driven innovation, and the award-winning commerce platform she helped architect.

Aparna Krishna Penumatcha’s Background

Aparna Krishna Penumatcha

When asked about her professional background and experience leading enterprise commerce transformations, Penumatcha shared:

I’m an Enterprise Commerce Architect with 18+ years of experience, all of it spent at IBM, where I’ve spent my career at the intersection of enterprise architecture and digital commerce. I hold a Bachelor’s in Computer Science and Information Technology from JNTU and a Master’s Program in Advanced Software Technology from the International Institute of Information Technology Pune in India, and I’m a Senior Member of IEEE , a Fellow of the Soft Computing Research Society and a Fellow of British Computer Society. I’m also certified at the L3 Thought Leader level under IBM’s Architect Profession certification (aligned to The Open Group’s Open CA standard), the most senior architect certification tier, reserved for architects with repeated, demonstrated experience directing significantly complex, strategic enterprise initiatives. I’m also certified by IBM as a Forward Deployed Architect (Thought Leader), which recognizes embedding directly with client teams to design, build and land agentic AI solutions in production enterprise environments, including commerce.

My path started in commerce platform development. I cut my teeth on WebSphere Commerce and SAP Hybris (now SAP Commerce Cloud) implementations for industrial distribution and electrical supply clients, and over time I moved into architecture and then into leading enterprise-scale transformations. Today I work as a Commerce Architect focused almost entirely on SAP Commerce Cloud, in its cloud-native CCv2 form, architecting large, complex digital commerce platforms for Fortune 500 companies across life sciences, healthcare, manufacturing, and technology.

Over the years I’ve led commerce architecture engagements spanning a global technology company (including its own internal commerce platform), a leading life sciences and laboratory supply company, a major biopharmaceutical company, a healthcare distribution company, and specialty chemicals manufacturers. A few of those engagements stand out: I was Chief Architect on IBM’s own IBM Commerce platform, which won an SAP Innovation Award and was selected as an internal “Client Zero” showcase for how IBM uses its own technology; I led the architecture to separate a major pharmaceutical company’s global B2B commerce platform into independent US and international instances; and I architected a multi-year eCommerce transformation program for a life sciences distributor, modernizing commerce, content, and product data across 36 countries and more than 15 million product records.

Alongside the client work, I’ve stayed active in research and thought leadership. I’ve published on cloud commerce deployment strategies, AI-accelerated development, and enterprise migration frameworks, including a paper accepted by IEEE Xplore. A lot of what I do now is less about writing code myself and more about setting architecture strategy, mentoring architects and engineering teams, and helping executives make hard platform decisions with confidence.

Why Enterprise Digital Transformation Programs Succeed Or Fail

Drawing on nearly two decades of experience at IBM, Penumatcha discussed the factors that determine whether large-scale digital commerce transformations succeed, emphasizing legacy systems, organizational alignment, scope management, executive communication, and employee adoption:

After leading dozens of these programs, I’ve come to believe the failures rarely come down to the technology itself. SAP Commerce Cloud is a mature, capable platform. What separates a successful transformation from a stalled one is almost always how the program handles legacy knowledge, organizational alignment, scope discipline, executive communication, and adoption.

Legacy Knowledge Is Often Undocumented

On nearly every large migration I’ve led, business logic that had accumulated over ten or more years, pricing rules, order approval workflows, availability logic, existed only in code, not in any requirements document. Programs that don’t budget real time to reverse-engineer that logic before design begins end up discovering it mid-build, which is exactly when it’s most expensive to absorb.

Enterprise Alignment Matters More Than Technology

As programs grow, teams naturally optimize for their own objectives. Without a strong architectural through-line connecting those workstreams back to one shared outcome, you end up with technically sound components that don’t add up to a coherent platform, plus duplicated effort and conflicting assumptions between teams that surface late and are expensive to unwind. The fix I’ve relied on consistently is establishing a single architecture governance layer, things like a shared decision log, a weekly cross-team architecture review, and one traceability model connecting every requirement back to the enterprise design, so that no team is building in isolation from the whole.

Scope Discipline Prevents Program Drift

Big-bang delivery is one of the most common ways these programs get into trouble. I’ve had far more success applying structured prioritization frameworks like MoSCoW, defining a minimum viable scope that’s genuinely launchable, and deferring everything else to a fast-follow release, than trying to deliver every requirement in one go.

Executive Communication Sustains Momentum

Architecture decisions have to be translated into business terms, revenue impact, risk reduction, time-to-market, not left as technical trade-offs. On the programs where I’ve secured sustained multi-million-dollar funding across many release cycles, it’s because every major decision was framed around a business outcome an executive could see and approve.

Adoption Is A Change Management Challenge

Technology adoption is a change management problem as much as a technical one. I’ve seen strong architecture struggle because testing teams didn’t understand the full business context they were validating against, or because business stakeholders weren’t given enough runway to understand new platform capabilities before go-live. The programs that succeed invest as much in educating the humans around the system as they do in building the system itself.

Critical Architectural Decisions For SAP Commerce Cloud

Discussing the most important architectural considerations when moving to SAP Commerce Cloud’s cloud-native CCv2 environment, Penumatcha emphasized data architecture, integration design, headless commerce, AI-related infrastructure demands, and long-term cost efficiency:

Some of the decisions consistently separate platforms that scale gracefully from ones that hit a wall.

Data Architecture Is The Foundation

Data architecture extends far beyond product data. It includes customer and user data, master data, transactional data (orders, carts, pricing), and content, each of which has a different volume profile, sensitivity level, and regulatory exposure. Too many programs treat data architecture as an implementation detail to be worked out module by module instead of a single strategic decision made upfront: what data lives where, how it’s classified, who owns it, and how it’s structured for both performance and governance. That includes data residency and regulatory constraints, which need to be built into the architecture itself, not bolted on later. If a platform serves multiple countries or regions, decisions about where customer, transactional, and master data physically reside, how it’s segregated, and how compliance regimes like GDPR are satisfied have to be structural properties of the design, not a patch applied after the fact. Getting the data architecture right early is comparatively cheap. Retrofitting it after go-live, especially once real customer data is already in the system, is one of the most expensive and highest-risk changes a program can make.

Integration Architecture Determines Scale

A lot of teams default to direct, point-to-point calls into ERP systems for things like real-time pricing or inventory. That works at small scale and falls apart at enterprise scale, because those calls tend to have uniform timeout behavior regardless of complexity, and a single large call for something like pricing becomes a bottleneck. Routing everything through a proper API gateway layer, with pagination and the ability to break large calls into smaller ones, plus a smart caching strategy for latency-sensitive data, is one of the highest-leverage architectural investments you can make.

Headless Commerce Improves Long-Term Maintainability

Using an adapter layer like Spartacus between the storefront and SAP Commerce lets the frontend evolve, scale, and even get replaced independently of the backend catalog and business logic. It’s the architectural decision that most directly protects your maintainability five years out.

AI Bot Traffic Is Now An Architecture Concern

Architecting deliberately for AI crawler and AI agent traffic, because it’s a real performance and infrastructure cost issue now, not a hypothetical one. On a recent engagement, we saw a meaningful spike in server load and infrastructure cost traced directly back to AI bots aggressively crawling the catalog, well beyond what traditional search engine crawlers ever generated. If that traffic isn’t identified and managed deliberately, at the edge or CDN layer, with differentiated caching and rate limiting for bot versus human traffic, it degrades real customer experience and drives up infrastructure spend unpredictably, sometimes without anyone realizing that’s the cause until they dig into the logs. This needs to be an explicit part of performance and capacity architecture now, not something handled reactively after a site starts slowing down.

Reuse Drives Long-Term Cost Efficiency

Every architecture decision should be documented and evaluated with an eye toward whether it can be reused across future rollouts, business units, or regions, not just whether it solves the immediate requirement. Programs that establish reusable integration patterns and architecture standards in an early phase consistently see meaningfully lower cost and faster timelines in every subsequent phase. On any decision involving new licensing, like a configurator or a specialized module, it’s also worth thoroughly evaluating platform-native options first, since I’ve seen teams default to an expensive add-on when the out-of-the-box platform, used well, natively supported the requirement at a fraction of the cost.

Avoiding Technical Debt During Legacy Commerce Migrations

When asked about common mistakes enterprises make when migrating heavily customized legacy commerce platforms to CCv2, Penumatcha highlighted the risks of carrying forward unnecessary customization, relying on outdated documentation, and overlooking long-term licensing costs:

Avoid The Lift-And-Shift Trap

The single biggest mistake I see is what I’d call the “lift and shift” mentality: treating migration as an exercise in faithfully recreating every existing customization on the new platform, rather than asking whether each one is still necessary. A huge amount of legacy customization was originally built to work around limitations of an old platform from ten or fifteen years ago, limitations that often no longer exist on a modern, cloud-native platform. If you port that customization forward without questioning it, you’re not migrating, you’re just relocating your technical debt to a new, more expensive home. The organizations that come out of a migration with a genuinely clean platform are the ones that force a “why does this exist” conversation on every single piece of legacy customization before it gets rebuilt, not after.

Don’t Trust Legacy Documentation

In nearly every heavily customized environment I’ve migrated off of, a decade or more of business logic, pricing rules, approval workflows, availability logic, existed only in code, undocumented anywhere else. Teams that don’t budget serious time for systematic reverse engineering, going through the legacy platform page by page and comparing it against what’s being built, discover these gaps mid-development, which is exactly when they’re most expensive and disruptive to absorb. That discovery work needs to happen at the very start of the program, as its own formal workstream, not as something the team stumbles into later.

Validate Scale Through Testing

Organizations tend to trust platform documentation and vendor assurances over actually testing their own scale. I’ve seen cases where a platform’s stated technical limits, confirmed multiple times by the vendor, turned out not to hold once real production-scale data was loaded. The lesson is to validate critical assumptions, storage limits, data volumes, performance under load, through actual proof-of-scale testing early in the program, not just take documentation at face value.

Establish Clear Data Ownership

Data migration ownership is very often left ambiguous between the client and the implementation team, and that ambiguity is a direct source of long-term technical debt. When nobody formally owns data cleansing and mapping accuracy from day one, the pressure of a deadline tends to push teams toward migrating data as-is rather than cleaning it up, which just carries old data quality problems, and old assumptions baked into that data, straight into the new system.

Risk That’s Easy To Overlook At Design Time

The licensing cost trajectory, not just the upfront price. I’ve seen organizations select a third-party module or accelerator because the initial licensing cost looked reasonable, only to face steep pricing increases later, per-user, per-transaction, or at contract renewal, that weren’t fully accounted for when the architecture was chosen. When that happens, teams are sometimes forced into a costly redesign to move off that component, work that could have been avoided by stress-testing the vendor’s pricing model against realistic growth scenarios up front, not just today’s usage. Any decision that creates a real dependency on a paid, proprietary component should come with an honest look at what the relationship costs at three times or five times current scale, not just what it costs on day one.

Governance Prevents Technical Debt

The practical fix that ties all of this together is governance. Every customization and licensing decision should go through a formal process, something like an Architecture Decision Document, that requires the team to explicitly state why a customization or third-party dependency is necessary, what alternatives were considered, including doing nothing and using the platform’s native capability, and what the cost and risk profile looks like at scale, not just at launch. That discipline filters out a lot of unnecessary customization and fragile vendor dependency before it ever gets built, and leaves a clear paper trail for anyone assessing the platform years later.

SAP Innovation Award And IBM’s Commerce Transformation

Discussing the IBM commerce transformation she architected, which received a 2026 SAP Innovation Award in the Customer Experience Innovator category, Penumatcha described how the project combined composable architecture, SAP Commerce Cloud, SAP CPQ, and AI to improve digital purchasing experiences:

The project was IBM’s own commerce ecosystem, rebuilt as a unified, composable foundation on SAP Commerce Cloud and SAP CPQ. It won the SAP Innovation Award in the Customer Experience Innovator category in 2026, under the title “Reinventing Customer Experience with AI-Driven, Composable SAP Commerce.” As Chief Architect on the program, covering both the direct B2C commerce platform and the B2B partner commerce platform, I can speak to what genuinely set this implementation apart.

For consumers, buying is simpler now, fewer steps, less friction, and far more people who start a purchase actually finish it. That’s brought us up to the level you’d expect from a well-run modern SaaS company. On the partner side, sales teams no longer retype the same deal information across three separate systems just to generate a quote, which cut cycle time significantly and reduced the risk of pricing errors. That kind of improvement doesn’t come from tuning an existing setup, it takes a genuine architectural rebuild.

What stands out most is that the architecture refused to force one configuration engine to do two very different jobs. B2C buyers needed something fast and lightweight enough not to add friction to a self-service purchase, while B2B partners needed something that could handle genuinely complex, rule-based configuration and pricing across thousands of product combinations, with AI-driven quoting on top. The architecture split that deliberately, SAP Commerce’s native product model for lightweight B2C configuration, and SAP CPQ specifically for the complex B2B scenarios, with AI-assisted pricing embedded in CPQ to dynamically optimize quotes. That split is a big part of why both sides of the business work well for very different buyers, instead of one side quietly being the compromise.

Above both of those transaction layers sits an orchestration layer, IBM’s own Experience Orchestrator, which let the experience and engagement layer evolve independently of the underlying commerce and CPQ engines, modular journey design, rapid feature releases, integration with external marketing platforms, without needing a full platform release every time. That’s what genuine composability looks like in production. Combined with AI woven through the architecture, personalized discovery and a watsonx-powered chat assistant on the B2C side, AI pricing on the B2B side, and generative AI accelerating the delivery lifecycle itself through IBM Consulting Advantage, that’s what SAP itself pointed to as the real differentiator: not platform consolidation alone, but orchestration and AI embedded at every layer.

The outcome matched the scale of the redesign. Three times as many customers who started shopping actually completed a purchase, which is what we mean by a 3x improvement in conversion. Direct customer acquisition grew 30 percent year over year, and the time it takes to get a new product ready to sell, what we call onboarding, became 300 percent faster. On the B2B side, generating a partner quote became 50 percent faster, with no need to retype the same deal information across separate systems, and the platform now supports more than 6,800 configurable products. All of this scaled to more than 50 countries for individual customers and more than 100 countries for business partners, running on continuous monthly releases, without costs climbing at the same pace as the growth.

Balancing Customization With Standard SAP Commerce Cloud Capabilities

Explaining how enterprises should determine when to customize SAP Commerce Cloud rather than rely on standard functionality, Penumatcha emphasized measurable business outcomes, direct customer feedback, and the long-term cost of maintaining custom features:

My honest position is that this decision should be driven entirely by business outcome, and if a business team wants something different from what the platform offers out of the box, they need to prove it with real evidence, not just a strong opinion from a meeting.

What that means in practice: before we build anything custom, I ask for two things. First, numbers tied to an actual business result, like sales, repeat customers, or average order size, showing that the standard experience is genuinely falling short somewhere specific. Second, and just as important, direct conversations with customers themselves. We regularly interview customers to understand their actual pain points, not just what shows up in a dashboard. Numbers can tell you where customers are dropping off, but they can’t always tell you why, and that “why” often comes straight from talking to the people using the platform. Between the data and those conversations, we usually get a clear, well-rounded business case for whether a capability is genuinely needed. “It would look better” or “our brand deserves something unique” isn’t proof. A clear drop-off point backed by customers telling us directly what’s frustrating them, that’s proof. Requiring this discipline does two good things: it stops us from building a lot of custom features that were really just personal preference, and it gives the features we do build a clear goal, so afterward we can actually check whether it worked.

This looks a bit different depending on whether we’re upgrading an old system or building something brand new. When we’re upgrading an old system, we usually already have both the usage data and years of customer feedback to draw on, so we can point to exactly where the old system is falling short. When we’re building something brand new, there’s no history to pull from yet, so I do the opposite: launch with the standard features first, track everything closely, and start those customer conversations early, then let real behavior and real feedback after launch tell us where custom work is actually worth it. It’s much cheaper to add something custom later, once we know it’s needed, than to build something custom up front based on a guess.

Once a request for something custom clears that bar, the next question is where to build it. A lot of what people ask for as a “custom feature” is really just about how something looks or how content is shown to different customers, not about changing how the core buying and pricing system works. On one large project I worked on, a client wanted every business customer to see a different, personalized version of the store. On paper, that looked like it would mean building a completely separate product catalog for every single customer, which would have been enormously expensive. Instead, I built a simple layer on top of the existing catalog that could show different content to different customers without touching the core system underneath. Whenever possible, that’s the better answer: solve the problem by changing what customers see, not by rebuilding the engine underneath it. It’s cheaper, and it doesn’t get in the way the next time we need to update the platform.

And even once something custom is truly needed and built in the right place, we still have to think about what it costs to keep, not just what it costs to build once. Custom changes to the core system usually have to be retested and sometimes rebuilt every time the platform gets a major update, while changes to how things look or are presented to customers usually don’t. So the full approach is simple: prove the business need with real data and real customer input, build it in the easiest place to change later, and go in knowing what it will cost to maintain for years, not just what it costs today.

Practical AI Applications In Digital Commerce

Discussing where artificial intelligence can deliver measurable value within SAP Commerce Cloud, Penumatcha identified opportunities involving product content, personalized discovery, conversational checkout, intelligent search, and platform reliability, while emphasizing the importance of data quality and human oversight:

There are multiple areas where AI is genuinely delivering value in commerce right now, not just promise. A few that stand out to me:

Product Content

Every commerce team faces the same problem, keeping product descriptions accurate, current, and translated across many languages and countries takes an enormous amount of manual work. AI is genuinely good at generating and translating that content now, and I think the smart approach is letting AI handle the bulk of it while still giving a person the ability to manually correct anything that needs a human touch, with the system remembering that correction rather than quietly overwriting it later. Done well, this alone can meaningfully cut the time it takes to get a new product ready to sell.

Product Discovery

Helping customers find and choose the right product, through personalized recommendations and conversational assistants that can answer specific product questions in real time while someone is shopping, rather than making them dig through pages or wait for a person to help.

Conversational, Zero-Click Checkout

This is one of the newer shifts, and I think it’s going to matter a lot more soon. Instead of a customer clicking through a traditional multi-step checkout, adding to cart, entering shipping details, confirming payment, a conversational assistant can complete the entire purchase inside the conversation itself, confirming details naturally and finalizing the order without the customer touching a traditional form at all. It removes friction at exactly the point where a lot of purchases get abandoned. It’s also becoming relevant for a different reason: as AI shopping agents increasingly act on a customer’s behalf, checkout has to work in a conversational, low-friction way that an agent can complete too, not just a human clicking buttons.

Search And Catalog Organization

This sits at the core of the commerce platform itself. Traditional search is rigid, it matches keywords, and if a customer searches using different words than what’s in the product data, they get poor results or nothing at all. AI-powered search understands intent and context, so it can return relevant products even when the search terms don’t match exactly, and it can also help automatically organize and tag a large catalog, which is normally a huge manual effort as a catalog grows into the tens or hundreds of thousands of products.

Platform Reliability, Or AIOps

Commerce platforms generate a constant stream of logs, performance metrics, and system alerts, and when something goes wrong, a slowdown, an error spike, a failed integration, it used to take a team a long time to sift through all of that manually to figure out what actually broke and why. AI can now spot unusual patterns almost immediately and point directly at the likely root cause, cutting the time it takes to detect and diagnose a production issue dramatically compared to a few years ago. For a commerce platform, where every minute of downtime or slowdown can mean lost sales, that speed matters directly to the business, not just to the engineering team.

None of this delivers real value without solving a few problems first, though, and I’d say these are the ones organizations most consistently underestimate.

Data Quality

AI is only as good as the product and customer data it’s working with. If that data is messy, outdated, or inconsistent, AI will confidently generate wrong descriptions or bad recommendations, and it’ll do it at scale, which makes the problem worse, not smaller. Getting the underlying data clean and well organized has to happen before AI gets turned loose on it, not after, and I think a lot of organizations get this backwards, rushing to deploy AI features on top of data they haven’t actually cleaned up.

Human Oversight

AI shouldn’t just make changes silently. Anywhere AI is generating or adjusting something customer-facing, there needs to be a real way for a person to review, correct, or override it, with the system respecting that correction going forward instead of reverting it. Without that, teams either stop trusting the AI or stop paying attention to what it’s doing, and both outcomes defeat the purpose.

Reliable, Real-Time Data Access

AI needs current inventory, current product information, and current customer history, through properly governed connections rather than quick workarounds. An AI recommendation based on stale or incomplete information isn’t actually helpful, it’s just a confident-sounding mistake.

The Future Of SAP Commerce Cloud And Agentic Commerce

Looking ahead to the next several years, Penumatcha discussed how generative AI, autonomous shopping agents, personalization, and emerging commerce standards could reshape digital transactions and the architecture supporting them:

Buying For An Audience Of Both People And AI Agents

I think the biggest shift coming is that commerce platforms will need to serve two very different kinds of buyers at once: people browsing and clicking through a storefront, and AI agents acting on a person’s behalf to research, compare, and complete a purchase automatically. Right now, almost everything about how commerce platforms are built assumes a human is doing the clicking. This is already starting to change in a concrete way, with an emerging industry standard called the Universal Commerce Protocol, backed by major retailers and platforms, that lets an AI agent discover what a merchant supports and complete a purchase directly, without every platform needing to build a custom connection to every AI system. Importantly, it’s built to hand off to a human when the agent hits something it can’t complete on its own, so it’s not about removing people from the process. It’s about making the process work for both. I expect standards like this to mature quickly over the next few years, and organizations that only design for the human path are going to find themselves invisible to a growing share of buying activity that happens through an agent instead.

Discovery Shifting From Search Engines To AI Assistants

For years, being found meant being ranked well in a traditional search engine. Increasingly, being found means an AI assistant or chatbot accurately understanding and recommending your product when someone asks it a question, sometimes called generative engine optimization. That means product content has to be structured clearly enough for an AI system to read, understand, and represent correctly, not just written to satisfy a search algorithm. I expect this to become as standard a discipline as traditional search optimization is today, and the companies that treat it as a real priority now, rather than an afterthought, are going to have a real head start.

Personalization Becoming Genuinely Individual

Personalization has mostly meant putting customers into broad segments and showing each segment a slightly different experience. AI makes it realistic to personalize to an individual customer’s actual context in real time: what they’ve looked at, what they’ve bought before, what’s relevant to them right now, rather than which broad bucket they happen to fall into. It’s the same underlying idea behind Amazon’s product recommendations, just applied to B2B buying rather than retail. I think that’s going to meaningfully raise the bar for what customers expect a good buying experience to feel like.

Architecture That Can Keep Up

All of this only works if the underlying platform is built to be genuinely composable, since new AI capabilities and standards are emerging quickly, and a platform that requires a major redesign every time something new needs to be added will fall behind. The organizations in the strongest position over the next few years are the ones that invested in flexible, well-integrated architecture now, not the ones trying to retrofit it later under pressure.

Trust Has To Scale With Autonomy

As AI takes on more of the decision-making, recommending products, setting prices, completing purchases, the need for clear oversight, good data, and the ability for a person to review and correct what AI is doing doesn’t go away. It actually becomes more important. I expect the organizations that succeed with this over the next few years to be the ones that took data quality and governance seriously from the start, not the ones that bolted AI onto a platform that wasn’t ready for it.

Composable Architecture, APIs, And Enterprise Integration Strategies

Explaining the role of composable architecture, APIs, microservices, and enterprise integrations in modern SAP Commerce Cloud implementations, Penumatcha emphasized balancing technological flexibility with the operational complexity of maintaining interconnected systems:

Composable Architecture

I think of composability as simply making sure different parts of your commerce platform, the buying experience, the pricing engine, the marketing tools, can each be changed or upgraded on their own, without having to touch or re-release everything else at the same time. In practice, this has usually meant decoupling the frontend from the SAP Commerce backend using an adapter layer like Spartacus, so the storefront can evolve independently of the underlying catalog and business logic. On one program, I took that further and split the frontend itself into three pieces, a shared common component library plus separate region-specific projects, so regional teams could build and release independently while still sharing a consistent foundation. When composability is done well, a team can redesign a checkout flow or plug in a new marketing tool in days instead of waiting for the next big platform release. It’s a genuinely valuable approach, but only when it’s solving a real problem, letting parts of the business move at different speeds. Composability for its own sake, breaking things apart just because it sounds modern, usually just adds cost and confusion.

APIs

Every connection between systems should go through a properly designed, documented, and monitored API, not a quick one-off connection built to solve today’s problem. I’ve seen this play out directly: on one platform, the default approach was making direct RFC calls into the SAP ERP system, which created a specific, measurable performance bottleneck, every function had the same maximum wait time regardless of how complex the request actually was. Replacing that with a governed API gateway layer fixed the bottleneck and became the standard integration pattern adopted across every subsequent rollout. That’s the real value of a well-governed API layer, it’s what actually makes composability possible in practice, since it’s the thing that lets separate pieces talk to each other reliably.

Microservices

These are a tool, not a default. Breaking a capability out into its own independently deployed service makes sense when that capability genuinely needs to scale differently, be updated on its own schedule, or be owned by a different team. One program I architected was actually built as an organization’s first MACH-compliant commerce platform, MACH meaning microservices, API-first, cloud-native, and headless, which is a useful industry benchmark for what this looks like when it’s done deliberately rather than just for its own sake. It doesn’t make sense to break everything into microservices just because it’s a common pattern elsewhere. Every additional service is one more thing to monitor, deploy, and keep secure, so the bar for creating a new one should be a real, specific reason.

Integration With Surrounding Systems

Whether it’s SAP systems like an ERP, or non-SAP tools like a marketing platform or a customer service system, I think the right approach is routing everything through a single, well-governed integration layer rather than letting every team build its own direct connection into every other system. On one program, we standardized more than 20 separate integrations, authentication, payments, analytics, marketing automation, content management, through a single enterprise integration layer built on SAP’s integration and gateway tools, rather than letting each one be built as its own one-off connection. That single layer becomes the one place you manage security, monitor for problems, and understand what’s actually connected to what, instead of that knowledge living in a dozen different places or, worse, only in one person’s head.

Where This Fits In The Enterprise Architecture

None of these decisions, composability, APIs, microservices, should be made in isolation by the commerce team. A commerce platform is one piece of a much bigger technology landscape, and the way it’s architected needs to align with how the rest of the enterprise is organized. The clearest example of this from my own experience is a program where SAP Commerce was positioned as one of just four strategic platforms across the entire enterprise, alongside major systems like Salesforce and Adobe, as part of a broader initiative to consolidate well over a thousand fragmented legacy tools down onto a small number of strategic platforms. That alignment matters for a very practical reason, most large enterprises are actively trying to reduce the number of overlapping systems they maintain, not add to that pile. When a commerce platform is architected with that bigger consolidation goal in mind, it ends up being far more valuable to the organization than a technically excellent platform that only makes sense on its own.

Balancing Flexibility With Complexity

This is really the whole question. Every piece of composability, every additional API, every additional service, buys you flexibility, but it also adds something a team has to operate, monitor, and keep working correctly. The way I’ve managed that in practice is through real operational discipline, weekly architecture review sessions, a formal decision log recording why every significant architectural choice was made, and strict performance benchmarks enforced every sprint. That kind of discipline is part of why some of the programs I’ve led delivered zero architectural reversals across many release cycles despite real complexity. Composable architecture done right gives a business real speed and flexibility. Composable architecture done carelessly just moves the complexity from one place to twenty places and makes it harder to see.