Author: Eric + Seema Amble

Translation: TechFlow

TechFlow Guide: Upgrading from SAP ECC to S4HANA costs $700 million, takes 3 years, and requires borrowing 50 people from Accenture—yet the world's largest enterprises still use it. This article from a16z dissects an intuitive judgment from an investment perspective: the future winners are not the companies that "replace SAP," but those that make SAP programmable and more user-friendly. This framework is highly valuable for understanding the real opportunities in the enterprise AI race.

The full text is as follows:

Startups in the AI field and their customers focus on new capabilities and the products that emerge from them: beautiful voice agents, workflow automation tools, text generation application platforms.

There are already many exciting companies in these areas, and there will be more in the future (we have invested in a few!). But the real impact of AI will come from something much less glamorous, but far more valuable: helping organizations extract more value from the vast amounts of software they already operate. There is a question that sounds almost offensive, but anyone who has spent a week at a Fortune 500 company will understand: why do people still use SAP (and ServiceNow, Salesforce)?

The short answer is: SAP or any major legacy record system embodies the core data of the enterprises using it. More importantly, businesses have done extensive customization on top of it and built a specific set of processes and responsibilities around it, many of which are not even documented. The cost of migrating is painful, expensive, and time-consuming—it often requires an army of consultants, years of time, and hundreds of millions of dollars. Upgrading from SAP ECC to SAP S4HANA might cost $700 million, take 3 years, and require a team of 50 people from Accenture. Once the migration is complete, the software can almost only be used to generate unusable read-only reports. Until now, AI has truly opened up the opportunity to upgrade, customize, replace, and better access and utilize the data embedded in these record systems.

Ultimately, the goal of AI may not be to "replace SAP/ServiceNow/Salesforce," but to make them more programmable and accessible. The winners will be those who can (1) reduce transformation budgets with measurable risks and timelines, and then (2) expand as a trusted control plane into daily operations, gradually breaking down legacy UIs into composable, governed AI-assisted operations and lightweight application platforms. In other words, record systems will exist for a long time; the interface layer, automation layer, and extension layer will become the new frontiers of software.

SAP is painful, but we still use it

First, let's briefly introduce what SAP is. At first glance, these systems are difficult to navigate and painful to modify, yet somehow they remain the operational backbone of the world's largest enterprises. Let’s take a look at what it's like to use SAP!

But that "somehow" is precisely where the opportunity lies.

The uncomfortable answer is: beneath the ugly UI and endless configurations, these systems are actually very powerful: they encode the authoritative data model of the enterprise, maintain compliance with relevant permissions and controls, support workflows for scalable operations, and integrate dozens (or even hundreds) of downstream processes. They are not "applications" in the consumer sense, but rather the organizational memory built on tables, roles, approvals, posting logic, and exception processing.

Replacing these systems is not only costly but also highly risky. Moreover, the more businesses invest in them—custom fields, workflows, pricing rules, reporting logic—the more this system will become a moat built on migration costs, and even a competitive advantage. This is also why scalability is so powerful: each enterprise is unique, changes are continuous (new regulations, new products, new organizational structures), and these platforms can survive precisely because they can be adapted to fit reality. The challenge is that the same scalability that makes them valuable also makes them vulnerable: every customization becomes a landmine for future upgrades, every workflow becomes a maze, and every interface is a tax on everyone who has to use it.

This vulnerability is everywhere. Despite widespread adoption of CRM, user satisfaction remains uneven; extensive customization of ERP continues to shadow with time and budget overruns. Employees are overwhelmed by fragmented workflows—digital workers switch between different applications about 1,200 times a day (losing about 4 hours a week); 47% of digital workers struggle to find the information needed to complete their work. Massive "digital transformation" projects frequently fail, with an estimated 70% not achieving their objectives. The scale of spending associated with this friction is enormous: the software implementation/system integration market alone is expected to be around $380 billion in 2023.

This process and pain points provide the opportunity for AI to change the way this type of software is implemented and used. The simplest way to understand this opportunity is to follow the lifecycle of the system: first you implement or migrate it, then you live in it every day, and finally, as the business changes, you build new things on top of it. At each stage, the nature of the work is to translate the chaotic human intentions into correct, auditable actions directed at the record system.

Let’s look at how AI can improve the usage of legacy software systems at each stage.

Implementation Stage

Starting with the implementation stage—this is the most risky, budget-sensitive, and yet clearly rewarding phase. Specifically, it’s about transforming chaotic requirement discovery (meetings, documents, tickets) into structured requirements and then automatically generating implementation workflows: process and field mappings, configurations and code, test scripts, go-live switch plans, migration manuals—along with the data cleansing and validation work required for go-live. This task is difficult to do well: the German retail giant Lidl once spent $500 million and still abandoned its attempt to migrate to SAP.

Companies in this space are building Copilots, project management tools, and other software to assist with migration and implementation. Here are some examples of startups working in this area (Andreessen Horowitz has invested in some of them):

Axiamatic is an AI "assurance" layer in the ERP space: it builds knowledge graphs from project artifacts, tagging hidden failures in requirement/change management via Slack/Teams to mitigate risks of S/4HANA projects and accelerate progress (in collaboration with SAP Build; embedded in workflows at KPMG/EY/IBM).

Conduct is a Copilot for code and process mapping, generating semantic layers and technical documentation for ECC→S/4 migrations, and supporting Q&A on custom tables/APIs to accelerate internal team handovers.

Auctor provides agent-driven implementation delivery for system integrators/professional services, automatically converting requirement discovery into structured requirements and serving as a record system for statements of work (SOW), design documents, user stories, configurations, and test plans.

Supersonik offers AI-empowered product enablement for resellers/MSPs and customers—visual and voice agents are trained within real UIs, reducing the need for pre-sales engineers, supporting reseller-led implementations and expansions.

Tessera's AI-native systems integrate end-to-end management of enterprise transformation—connecting to existing customer ERP instances, evaluating their implementation status, and then marking and automatically fixing items that need to change during migration.

These companies create value by making transformations faster, cheaper, and lower risk. This is reflected in several ways: early identification of issues in requirements and change management, preventing a snowball effect of problems; compressing project timelines (a month delay can cost millions); transforming chaotic project data into structured knowledge, allowing internal teams to take over faster; and reducing reliance on large system integration teams through automated mapping, documentation, testing, and enablement training.

We believe there is space for more startups to build tools that collaborate rather than compete with existing partners. Specifically:

Implementation agents that share outcome and risk (covering requirement tracking, configuration comparisons, switch simulations, code generation, and drift detection)

Semantic documentation tools that keep knowledge real-time updated and accessible

Enablement agents that transform training and channel promotion into reusable products

Because startups can alleviate the enterprise burden, they can price based on the "value of avoiding delays" and penetrate the transformation budgets that CIOs and CFOs are already investing, while also replacing cumbersome system integrator contracts.

Usage and Maintenance Stage

After the software suite is implemented, daily usage means navigating through these software's chaotic UIs today. Daily work spans across dozens of interfaces, constant personnel turnover zeros out existing operational knowledge, and many edge case workflows never receive first-class treatment at the core product level. Users spend a significant amount of time searching for fields, mirroring data between systems, asking operational teams to "run this report for me." The result is slow cycle times, frequent avoidable errors, and an ongoing training burden.

The opportunity for AI lies in wrapping legacy systems with a more friendly, capable "action system."

This category of companies build tools that help teams extract more value from the systems they are already using. In practice, this looks like a Copilot living in Slack or existing as a browser sidebar—it can answer the questions "Where is X?" or "How do I do Y?" through semantic search and execute safe operations (creating tickets, posting entries, updating vendor terms) when APIs are available. These tools can also connect composite workflows across applications ("pull the last quarter's purchase order from SAP, check contract terms in Coupa, draft a discrepancy notice in ServiceNow"), with manual approval steps, audit trails, and granular permission controls. The best tools will also track adoption rates, time saved, and error rates.

In enterprises, much important work is not cleanly exposed through APIs—it exists within interfaces, thick clients, VDI sessions, and semi-documented management consoles. This is why modern "computer use" agents are an important complement to API-first Copilots: they extend the reach of automation to that last 30%-40% of workflows that have no reliable calling endpoints.

The core capability is not in "clicking buttons," but in remaining reliable amidst chaos—being able to sense the UI, anchor stable elements, recover from pop-ups and layout drifts, and set checkpoints for safe mid-process recovery.

When combined with validations (differences comparison, verifications, sandbox runs) and enterprise governance (SSO, key management, least privilege, audits), this turns work that previously had to be done manually—ticket classifications, month-end closing steps, customer updates, pricing changes—into governed, reusable automation, even in parts of SAP/ServiceNow/Salesforce where vendors have never built for automation. APIs make straightforward paths fast, while computer use makes long-tail workflows automatable.

Companies like Factor Labs and Sola have already deployed such agents in production environments, replacing BPO expenditures and helping large organizations achieve scalable task automation.

Finally, even if you make SAP/ServiceNow/Salesforce easier to use, the business will continue to change, which means the record system must evolve as well. New products, new policies, new acquisitions, new regulations, and the ever-increasing long-tail workflows that can never support a core module project mean the software must continuously keep pace with the real status of the business.

Historically, teams only had two options: customize the software (and inherit the cost of vulnerability), or build one-off applications (and struggle with integration, governance, and maintenance). This is AI's third entry point: to rapidly deliver small, governed experiences on top of record systems while keeping the core system clean.

Building entirely new tools and automation on top of legacy systems creates a "Lovable layer" above those "unloved software." This model starts with a unified data and action plane of normalized business object semantic models (orders, vendors, tickets) read from record systems through APIs and events (using secure UI scraping when necessary), and then exposes a set of governed operations with permission controls, approval flows, and audits.

On this plane, teams deliver experiences that feel modern and are designed for specific scenarios. Instead of having procurement analysts navigate 12 transaction codes in SAP to complete a vendor onboarding, it is better to provide them a single "vendor onboarding" lightweight application—collecting documents, check for duplicates, routing approvals, and writing back the correct records to SAP.

Instead of requiring RevOps to open five Salesforce interfaces to update renewal terms, it is better to give them a spreadsheet-speed editor that supports bulk editing, policy validation, impact previews, and then submits changes with complete audit trails. Rather than launching another "portal project," it is better to give frontline teams a command panel that can answer questions and perform their daily operations across multiple systems ("create a return," "extend credit limit," "open a P2 issue ticket," "post accrual"), without needing to flip through 20 tabs.

These expansions can also unlock cross-system workflows and automation—those that no single vendor would prioritize building: event-driven triggers, like "if invoice is posted and difference >3%→draft explanation→route for approval," or "if ticket is reopened→create issue records→assign owner→update customer," with manual intervention checkpoints set at crucial points.

Over time, the most valuable deployments will evolve into reusable "intention packs"—from quote to cash, vendor onboarding, month-end closing—not just encoding what to do, but also encoding how to do it safely in your environment.

Platforms like Cell from General Magic make it easy to build the foundational modules for these custom workflows: you upload OpenAPI specifications, each endpoint becomes a callable operation, and then embed a native command bar with a line of script that can execute real API calls, complete with analytics, multi-tenancy, safety barriers, and permission controls—the focus of work thus shifts from "building yet another UI" to "combining the right operations and strategies on top of the systems you already trust."

What does the endgame look like?

We believe that legacy systems are likely to continue existing, but they will no longer be the interfaces where work happens. ERP, CRM, and ITSM suites are too deeply embedded to be fully replaced at the tempo of ordinary software; they evolve slowly and will continue to be the record systems. What will change is the user-facing "action systems" layered on top of them: AI will become the default interface for discovering how systems operate, executing workflows across systems, and delivering small modernized experiences that bypass legacy UIs. In other words, the bridge will become the highway.

The software that persists in this category will likely not look like a chatbot but rather like an operating system layer: a unified data and action plane with business object semantic models, combined with trusted safety barriers that make AI reliable in production environments. If you are a end user, you will no longer need to learn which interface, which field, or which transaction code to use (nor relearn after every UI or process change), but rather describe the outcome you want, and the system will guide you there.

The system will ask a few clarifying questions, show you a preview of what it is about to do, and then complete the execution with the proper approvals and audit trails. The final closed loop will look like: "Create a return and notify the customer," "Open a P2 issue ticket and pull the last three relevant events," or "Onboard this vendor, collect documents, route for approval, set payment terms"—and these operations today require jumping back and forth between SAP, Salesforce, ServiceNow, and spreadsheets. This results in fewer errors and reworks, less reliance on "tribal knowledge," faster cycle times, and greatly reduced training burdens—because the interface drives intent, is role-aware, and defaults to self-service.

The moat accumulates with real usage: every successful workflow becomes a reusable intention, every exception becomes a safety barrier, and every migration artifact becomes a living data lineage, deepening the map of how the enterprise operates over time. As time progresses, the "AI layer" will become the destination for teams to understand change impact, prevent drift, measure ROI, and deliver new workflows—even if the underlying systems remain unchanged.