Introduction
In the world of product development, one thing is clear: the use of standard software will become increasingly important in the future. In this article, we outline the reasons for this trend, present a five-step process for successful integration, and highlight the new skills companies will need to meet these challenges.
Why standard software is becoming more important
The software market is more differentiated than ever: for many processes, specialized solutions exist – from accounting to time tracking. Whether for internal workflows or customer-facing offerings, companies can usually find a tool today that meets their requirements and makes work easier.
In the past, many things were pieced together in Excel, squeezed into large all-in-one solutions (e.g. SAP), or built in-house due to a lack of alternatives. Today, it is worthwhile to invest time in research to understand how an existing problem is already solved in the market. This abundance of ready-made solutions lowers the perceived risk and effort of building software in-house. At the same time, many standard solutions are highly specialized and cover only parts of a problem. In practice, this increasingly leads to hybrids of standard software and custom development within a given domain.
Examples of standard software that can be integrated into a domain
- Luigi’s Box: Preconfigured and optimized search, product recommendations, and product pages for web shops. Instead of developing these functions in-house, teams can integrate them and save development time.
- SmartPricer: Plug-and-play pricing dynamics for ticketing providers – integrating market analysis and behavior-based dynamic pricing into existing solutions.
- AI Components (LLMs): Many companies will embed large language models in their products, but few will build their own. Instead, they will use models and services provided by vendors such as OpenAI, Amazon, or Google to gain advantages quickly and cost-effectively – without the heavy investments required to train and operate their own models.
The promises of standard software
Three frequently cited promises are:
1. Faster time-to-market
Standard software saves development time – offers can be rolled out faster.
2. Reduced cognitive load for employees
When entire process components are provided as services, teams can focus on the parts of their domain that truly differentiate them.
3. Better return on investment (ROI)
Vendors bundle expertise and best practices. Instead of building error-prone in-house solutions, companies benefit from mature products and continuous improvements.
Where are the risks?
Why do we speak of ‘promises’ instead of simply ‘advantages’? Because in practice, integration often turns out to be neither as easy, fast, nor cost-efficient as expected.
One central reason: the sense of ‘buying off the shelf’ often leads to neglecting established agile best practices. Methods proven in custom software development – such as continuous testing, early validation, or tight feedback cycles – fade into the background. The result can be unpleasant surprises: interfaces that don’t fit, data that isn’t semantically compatible, or processes that fail to adapt smoothly.
The right mindset for integrating standard software
At their core, all agile and product management methods (e.g. product discovery, experiments, MVPs) share one principle: risk minimization. The goal is to quickly and cost-effectively validate whether you are building the right product.
This mindset applies equally to standard software integration. It should be planned, tested, and challenged just as deliberately as custom development.
Process for integrating standard software
The following process helps integrate standard software in a risk-minimized way.
Step 1: Create alignment
Step 2: Define success
Step 3: Run experiments
Step 4: Agile integration
Step 5: Measure and evaluate
Each step is explained in detail below.
Step 1: Create alignment
Before starting, all stakeholders need a shared vision of the goal. Key questions include:
- What outcomes should be achieved?
- What hypotheses support the assumption that the software will deliver these outcomes?
- Which use cases should the software cover?
- Which use cases or edge cases can be consciously excluded?
- Will the software become part of our USP, or does it support supporting processes only?
- Is the organization aware of which processes the software will affect, and what the consequences are?
- Is the organization ready to adopt the processes the standard software imposes?
- How big is the risk if we build little or no knowledge in this area internally?
- What test phase can we agree on with the vendor – ideally with an easy exit option?
- What commercial and technical risks are already known?
Step 2: Define success
Clear success criteria are essential:
- How do we concretely define success?
- Which metrics and KPIs will measure it?
- What happens if the software does not deliver success? (e.g. exit scenarios, alternatives)
Step 3: Run experiments
Small experiments help test assumptions and minimize risks:
- Check data fit: Do existing data align with the software’s requirements? Developers can often spot potential risks simply by reviewing API specs and documentation.
- Functional and technical tests: Run representative test data through scenarios and validate whether the expected benefits are achieved.
- Test non-functional requirements (NFRs): For example, verify scalability and performance through load testing.
Step 4: Agile integration
In our experience, this step hides significant risks. The assumption is that standard software can be plugged in like an appliance and will just work.
But anyone who seriously analyzed interfaces and conditions in Step 3 knows: integration takes time and can be complex. That’s why integration should be done agilely:
- Identify the smallest possible proof of concept to minimize risk
- Build early end-to-end connections to ensure systems actually interact
- Develop iteratively and gradually roll out additional features
Step 5: Measure and evaluate
After integration, objective success control is crucial:
- Did the desired outcome materialize?
- What actions follow from the results?
- Decide: continue, adapt, or exit
Necessary skills for companies
To meet the challenges of integrating standard software, companies need specific skills. Three core skills stand out:
1. Researching standard software
Teams must be able to systematically explore the market: Which solutions exist? Which problems do they solve – and which do they not?
2. Decentralized make-or-buy decisions
Traditionally, management made these decisions, as they often involved large systems and investments. Today, such decisions increasingly occur in smaller units (e.g. product teams or departments) that need to move quickly. These units must decide independently whether to build or buy – and own the decision.
3. Driving risk-minimized integration
The biggest challenge is often integration itself. Risks regarding feasibility and effort are frequently underestimated. Companies need a mindset and practices that treat integration as a learning process: small steps, early testing, clear success criteria. Over time, experience will make handling these risks routine and prevent costly missteps.
Summary
There are excellent software solutions for standard problems on the market. Few companies will want – or be able – to build all components of their offerings entirely in-house in the future. The integration of standard software into product development will therefore become more common. Standard software can save development time, reduce cognitive load in teams, and increase ROI.
To realize these benefits, product teams need a mindset of risk minimization and the right skills. Because integration – even of great software – can be demanding. The described five-step process provides a structured approach to integrate standard software successfully.
In the future, the ability to effectively research standard software, make decentralized make-or-buy decisions, and drive risk-minimized integrations will be decisive for the success of product teams. Equipped with these skills, companies can fully leverage the benefits of standard software and position their products successfully in the market.