Low-Code at Enterprise Scale: Lessons from SAP Build Early Adopters

Low-code development promises to radically accelerate application delivery by empowering “citizen developers” – business users with minimal coding experience – to build apps and automations. In the SAP world, SAP Build is leading this low-code charge, offering a suite of tools to create apps, automate processes, and design business sites with drag-and-drop simplicity. But how does this play out in large enterprises in reality? Early adopters of SAP Build have achieved impressive results, yet they also encountered challenges and learned valuable lessons when scaling low-code initiatives enterprise-wide.

If your organization is curious about low-code (or already dabbling in it), you’re likely wondering: How do we go from a few quick apps to a sustainable, governed low-code program? How do we balance the speed and creativity of citizen development with the need for security and quality? And what role do our IT teams and possibly external partners play in this journey? This blog will dive into those questions by examining the experiences of early SAP Build adopters. We’ll explore patterns in how enterprises start with low-code, common pitfalls to avoid, and best practices to unlock low-code’s full potential – all while ensuring you have the right people and talent strategy in place to support it.

The Rise of Low-Code in the Enterprise

Low-code development is not just a buzzword; it’s a response to very real pressures. Business needs are evolving faster than traditional IT can deliver. Departments often have a backlog of requests for new tools or process improvements, and IT teams struggle with limited developer capacity. Low-code platforms address this gap by enabling more people in the organization to build solutions without waiting in the IT queue.

The trend is undeniable – Gartner predicts the adoption of low-code development platforms will grow about 20% annually, reaching $44.5 billion by 2026​ In other words, enterprises worldwide are investing heavily in these platforms to speed up digital initiatives. SAP Build is one such platform, tailored for SAP environments. It allows you to visually compose applications and automate workflows, tapping into your SAP data and processes with ease. Early users of SAP Build have reported development speeds up to 3x faster for certain projects​.

Why is low-code so attractive? For one, it democratises development – your finance or HR analyst with a knack for problem solving can create a workflow app, instead of only professional developers doing so. It also promises faster time to value; what once took months of IT development can sometimes be done in weeks or days by a business user who knows the problem best. Additionally, low-code can help bridge the IT skills gap. Good developers are in short supply, so empowering non-developers helps expand your development capacity from within.

However, as more enterprises dip their toes into low-code, a nuanced reality is emerging. Low-code is powerful, but it’s not magic. Without the right approach, you can end up with a proliferation of half-baked apps, security risks, or disillusioned users. Scaling low-code in an enterprise requires just as much thought as any other IT initiative – perhaps even more, because it blurs the line between business and IT responsibilities. Early adopters have illuminated both the bright spots and the pitfalls, giving us a roadmap of what to do (and what not to do) when rolling out SAP Build at scale.

SAP Build in Action: How Early Adopters Started

Many early SAP Build adopters began with a specific use case or a pilot project that showcased the platform’s potential. For example, a company might start by automating a simple approval workflow that had been done via email, or building a small app to let factory floor managers log equipment inspections more easily. Starting small makes sense – it allows you to prove the value quickly and learn the tool without huge risk.

One illuminating example is Freudenberg Group, a global manufacturing conglomerate and an early adopter of SAP Build. Freudenberg’s Corporate IT team first built a single use-case application and saw a successful go-live with SAP Build. This initial win gave them confidence to expand. In April 2023, they formally launched a low-code Center of Excellence (CoE) called the “Confactory” and held an internal “SAP Buildathon” – a two-day hackathon style event involving over 30 aspiring citizen developers from across the company​. During this event, participants created real solutions using SAP Build and brainstormed many more ideas for apps and automations. The result was “real momentum among business users to build low-code apps on their own”, according to Simon Jarke, Freudenberg’s head of Corporate Digital Innovation​sap.com.

Freudenberg’s approach highlights a few common patterns among successful early adopters:

Executive Sponsorship and Enthusiasm

Freudenberg’s IT and digital innovation leaders actively championed the low-code initiative. By dedicating two days to a company-wide hackathon, they sent a clear message from leadership that citizen development is encouraged and valued. Many early adopters find that having a high-level sponsor (like a CIO or Chief Digital Officer) who is excited about low-code is crucial to break down initial skepticism.

Engaging the Business Early

Rather than keeping low-code confined to IT, they involved business users from the start (30 citizen devs from various departments). This builds a sense of co-ownership. The people who will ultimately benefit from these apps were directly involved in creating them, which drives higher adoption and enthusiasm.

Creating a Structured Program

The formation of a CoE (Center of Excellence) provides a framework to support and govern low-code development. Early adopters often establish a dedicated team or at least a lead person/group to define best practices, provide guidance, and manage the pipeline of low-code projects. Freudenberg’s “Confactory” is an example of giving the initiative an identity and a home – which helps sustain momentum after the initial excitement of a pilot.

Celebrating Quick Wins

The hackathon approach led to quick development of multiple prototype solutions in days. Showing these quick wins enterprise-wide helps prove the concept. People start to see tangible outcomes – “Oh look, we built a working app in 48 hours that solves X problem.” Early successes are often publicized internally via demos or internal newsletters, sparking ideas in other departments about what they could do with SAP Build.

In summary, early adopters kickstart low-code by combining a small but meaningful pilot (to learn and demonstrate value) with broad engagement (to generate buy-in). They treat low-code not as a trivial side experiment, but as a strategic initiative – albeit one that starts with agile, small steps.

Challenges in Scaling Low-Code Across the Enterprise

After the initial pilots, companies often aim to scale up their low-code efforts: more apps, more citizen developers, and more business processes improved. This is where new challenges tend to emerge. Early SAP Build users have encountered several common hurdles when trying to go enterprise-wide:

Governance and Control

By opening app development to the masses, you also open the door to potential chaos if not governed. It’s essential to avoid the rise of shadow IT – e.g. dozens of untracked apps accessing sensitive data or duplicating logic. Ensuring compliance, security, and quality standards becomes a big focus. In fact, 47% of organizations implementing low-code are establishing formal governance policies to manage it​. Early adopters learned that governance isn’t about putting a damper on citizen creativity, but about setting guardrails. This might include guidelines on what data can be used, requiring IT review for certain types of apps, or using SAP Build’s built-in governance tools to assign roles and approvals for publishing apps. Neglecting governance can lead to messy outcomes – for instance, two departments might unknowingly build redundant apps for the same purpose, or a well-meaning employee might create a solution that inadvertently exposes sensitive data.

Integration and Complexity

Low-code doesn’t mean no-code, especially in an enterprise setting. Often, the real power of SAP Build apps comes from integrating with back-end SAP systems (like pulling data from S/4HANA or writing back to it). Early users discovered that while simple standalone apps are easy, the moment you need to connect to core systems or complex data models, you may need more technical expertise. Setting up those integrations, ensuring performance, and handling errors require knowledge of both the business process and the underlying technology. Some companies addressed this by pairing citizen developers with professional developers for the more complex projects. Others created reusable integration components (perhaps built by IT) that citizen devs can plug into their apps. The lesson: acknowledge the limits of what a business user can do alone and have a support system for the tricky parts.

Skill Gaps and Training

The term “low-code” might imply anyone can do it with no training, but in reality early adopters found that users still need to learn how to use the platform effectively. SAP Build has a learning curve – citizen developers must grasp the logic of building apps or automations, even if they’re not writing code syntax. Without proper training and support, some users might create poor solutions or get frustrated and give up. A challenge is identifying the right people – not every business user will be interested or adept at app-building just because the tool is simpler than coding. Many companies implemented training programs, from formal courses to internal communities of practice (regular meet-ups of SAP Build users to share tips). Freudenberg, for example, didn’t just unleash 30 employees on SAP Build blindly; they guided them through building use cases in the Buildathon with coaching available. The takeaway: invest in developing your citizen developers – through training sessions, documentation, and perhaps a “buddy system” where each new citizen dev has an IT mentor.

Changing Roles and Resistance

Low-code can blur lines between IT and business roles, which sometimes causes organizational friction. Some IT professionals might feel threatened or skeptical about citizen development (“are these amateurs going to create more work for us fixing their mistakes?”). Conversely, some business users might be hesitant to take on what they see as “IT work” in addition to their regular job. Early adopters have tackled this by clearly defining roles and collaboration models. For instance, establishing that IT still provides the platform, oversight, and hard integration work, while business experts focus on the functional side of the app. One successful model is creating cross-functional low-code teams for projects – an IT person, a business person, maybe a UX designer – so it’s truly a team effort and everyone sees value. You need to actively manage cultural change: reassure IT that this actually frees them to focus on more complex development, and reassure business folks that the goal is to make their jobs easier, not add burdens.

Prioritization and Scale Management

When word spreads that “anyone can build an app,” you might get a flood of ideas and requests. That’s a good problem to have, but it requires a way to prioritize which projects to pursue and to ensure maintenance of what gets built. Some early adopters set up an intake process as part of their CoE – employees submit ideas for apps, which are then reviewed for impact and feasibility. This keeps the focus on high-value use cases aligned with company goals, rather than just random apps. Additionally, as the number of apps grows, you must consider maintenance: who updates an app if the process changes or if there’s a bug? Without clear ownership, apps can fall into disrepair. So governance again extends to lifecycle management – making sure every app has an owner and a maintenance plan, even if it was built in a day. As one SAP expert noted from real-world experience, successful low-code requires setting up a lifecycle management process and a Center of Excellence to oversee it​community.sap.com.

Recognizing these challenges early allows you to design your low-code program intentionally rather than reacting later. In the next section, we’ll translate these hard-won insights into concrete lessons and best practices you can apply.

Lessons Learned from Early Adopters of SAP Build

Early adopters of SAP Build have shared a wealth of knowledge about what it takes to make low-code work at enterprise scale. Here are some of the key lessons and best practices that have emerged from their experiences:

Treat Low-Code as a Strategic Initiative

Don’t think of SAP Build apps as throwaway little tools. Approach low-code with the same seriousness as any development strategy – align it with business objectives and get leadership support. One early adopter pointed out that the business perspective is crucial in low-code projects to ensure they truly meet process needs​. This means involving business stakeholders in planning which areas to target with low-code and ensuring projects are solving real pain points.

Establish a Governance Framework Early

Set up a low-code Center of Excellence (CoE) or at least clear guidelines from the start. Define what kind of apps can be built by citizen developers independently and what requires review. Implement basic standards for documentation, security checks, and app approvals. Early adopters like Freudenberg chose a federated governance model – meaning central governance existed, but each business unit also had some responsibility in managing their apps. This hybrid approach can balance control and agility. Whatever model you choose, communicate it widely so everyone knows the “rules of the road.”

Provide Training and Ongoing Support

Invest in your people by offering training programs for SAP Build. This could include formal training sessions, online tutorials, or interactive workshops (like hackathons or “app days”). Pair new citizen developers with experienced mentors (from IT or from those who have built a few apps successfully). Create an internal community – for example, a MS Teams channel or forum where folks can ask questions, share tips, and showcase what they built. Early adopters found that an enthusiastic community of practice greatly accelerates learning and keeps momentum going.

Start with High-Impact, Low-Complexity Use Cases

Not every process is a good candidate for a first low-code project. Early wins often come from automating or simplifying processes that are currently manual or Excel-based, where an app can make a noticeable difference but doesn’t require extremely complex logic. By carefully selecting initial use cases that are small enough to be built quickly but significant enough to matter, you can demonstrate value without getting bogged down. This builds credibility for the program. As confidence grows, you can tackle more ambitious use cases.

Foster Collaboration Between Business and IT

Low-code shouldn’t create a wall between business developers and professional developers – it should bring them closer. Encourage joint project teams. Many early adopter companies ensured that for each citizen-developed app, an IT person was in the loop to provide guidance on data integration or compliance. Likewise, some IT departments started adopting a mindset of service enablement – treating the citizen devs as internal customers to support. This collaborative culture prevents the “us vs. them” dynamic and results in better, more robust applications.

Use Guardrails, Not Handcuffs

Governance is necessary, but avoid smothering the creativity and speed that make low-code attractive. Instead of forbidding business users from doing anything interesting, provide templates and guardrails to guide them. For instance, an IT team might provide pre-built connectors in SAP Build for common data sources, so a citizen dev can easily use those instead of writing a risky custom integration. Or they might enforce that any app which impacts finance data gets a code review by a pro developer, but things like a simple notification app might be free for anyone to publish. Early adopters that struck the right balance here enabled innovation while maintaining trust in the solutions. One could say: empower users, but within a safe sandbox.

Monitor and Measure Value

As you scale, keep track of the outcomes. Successful early programs often set up KPIs or at least collected success stories: e.g., number of apps built, hours of work saved, reduction in IT backlog, user satisfaction scores, etc. This data not only helps justify the low-code program (especially to executives holding the purse strings), but also helps identify what’s working or where more support is needed. If one department built 10 apps but none are really used, that’s a sign to investigate and possibly provide more guidance. If another department saved $100k by streamlining a process, celebrate and publicize that win! Data-driven insights will help you continually refine your approach.

In essence, the lessons from early adopters boil down to this: plan and support your low-code initiative as an ongoing capability, not a one-time experiment. It’s about people as much as technology – enabling your employees with new skills and creating a structure that allows innovation to flourish while keeping it all sustainable.

The Critical Role of Talent and Partners in Low-Code Success

Implementing SAP Build at scale isn’t just a technology rollout; it’s about having the right talent and possibly external support to nurture the program. Early adopters often cite the importance of key roles and partners in making their low-code journey successful.

Internally, you may find you need to designate or hire for certain roles:

• Low-Code Platform Owner or Lead: Someone (likely in IT or an innovation team) who is responsible for the overall SAP Build platform – administering user access, monitoring usage, and being the go-to expert. This person keeps an eye on governance and liaises between IT and business.
• Solution Architects/Integrators: Professionals who can handle the tougher technical parts (setting up data models, integrations, ensuring performance for apps that become mission-critical). They work behind the scenes to make sure citizen devs have a solid foundation to build on.
• Change Champion/Trainer: As discussed, training is continuous – having an in-house evangelist who organizes workshops, shares updates on new SAP Build features, and coaches citizen developers can maintain momentum.
• Citizen Developers: And of course, the business users themselves who take on low-code development. While this is typically not a full-time role, some companies formally recognize and allocate time for employees to do citizen development as part of their job. For instance, a finance analyst might be given 10% of her time to work on approved low-code projects. Recognizing and rewarding this work is key so that these individuals remain engaged.
  

Not every organization will have all these roles immediately, but it’s worth considering how to fill these needs. This is where working with an IT staffing or consulting partner can be extremely beneficial, especially in the early stages. If you’re kicking off a low-code initiative and lack certain expertise, an experienced partner can provide:

• Strategic Guidance: Consultants who have helped other companies implement low-code can assist in designing your CoE, governance model, and adoption strategy. They can share frameworks or playbooks so you don’t start from scratch.
• Initial Setup and Development Help: You might bring in an SAP Build expert to set up the platform correctly (security, connectivity to your SAP systems, etc.) and even develop the first few applications alongside your team. This on-the-job training is invaluable – your team learns by doing, with a safety net.
• Scaling Support: As demand grows, you might need additional skilled resources temporarily. For example, if several departments want to build apps at once, an IT consulting firm could supply extra low-code developers or trainers for a few months to handle the surge, ensuring no one is left waiting and enthusiasm doesn’t fizzle out due to lack of support.
• Governance and Quality Assurance: Partners can also play a role in reviewing apps for quality or security until your internal practice is mature. Think of it as a code review, but for low-code artifacts – an external expert can certify that an app is built following best practices. This knowledge again transfers to your team over time.
  

The goal of involving a partner isn’t to outsource low-code development entirely (that would defeat the purpose of empowering your own people). Rather, it’s to accelerate learning and provide expertise at critical moments so that your program is set up for long-term success. A good partner will focus on enabling your organization – helping you build internal capabilities and confidence.

Another aspect of talent is the culture you cultivate around low-code. Encourage a growth mindset in employees: emphasize that it’s okay to try building something and learn from failures (of course, failures are small-scale if governed well). The more people feel supported – whether by internal peers or external advisors – the more they’ll experiment and innovate.

Finally, consider the staffing implications as low-code becomes part of your enterprise DNA. Over time, you may find traditional roles evolving – for instance, some business analysts might become full-time automation specialists, or some developers transition to more advisory roles guiding citizen devs. Embrace these shifts. They can actually improve job satisfaction (people get to work on more interesting problems) and help with talent retention. Companies that have advanced in low-code often find they attract new talent too – tech-savvy professionals who are excited to join a company that leverages modern ways of working.

Conclusion: Accelerate Your Low-Code Journey Today

The early adopters of SAP Build have shown that low-code can be a game-changer for enterprises – if approached with the right strategy and mindset. It’s not a silver bullet that automatically delivers results; it’s a powerful tool in the hands of your people, and its success depends on how you empower and guide those people. By learning from those who’ve gone before, you can avoid pitfalls and leapfrog straight to best practices.

Imagine a future a year from now: instead of a backlog of unmet business needs, you have dozens of agile apps and automations built by cross-functional teams, streamlining work in every department. Your IT department is no longer seen as a bottleneck, but as an enabler, providing a robust SAP Build environment and support. Your business users are not frustrated waiting for solutions – they are proactively creating and improving their own processes, with a safety net of governance ensuring everything remains secure and maintainable. That’s the promise of low-code at enterprise scale: faster innovation, closer IT-business alignment, and a more digitally fluent workforce.

To get there, start planning your low-code journey now. Don’t wait until you’re overwhelmed by demand or until shadow IT takes root. Take a page from the early adopters – run a pilot, set up your governance early, invest in training, and celebrate those quick wins to build momentum. And remember, you don’t have to figure it all out alone. Whether you need a roadmap for building a low-code Center of Excellence or experts who can jumpstart your first projects, consider tapping into experienced partners who specialize in this space.

Ready to accelerate your low-code transformation?

Cogent Infotech is here to help. Our team has worked alongside SAP Build early adopters and knows what it takes to succeed. From establishing a governance framework to upskilling your staff or augmenting your team with low-code specialists, we provide end-to-end support tailored to your needs.

Contact us to kickstart your low-code journey – let’s collaborate to turn your innovative ideas into reality quickly and safely, and position your enterprise for ongoing agility in the digital age. Your competitors are exploring low-code; with the right strategy and partner, you can leap ahead and set the standard. The low-code revolution is here – make sure you’re not just watching from the sidelines, but leading the charge.

‍