Software modernization for device software,
machines and industrial systems
Qwasaa modernizes long-established software in devices,
machines and industrial systems.
With structured analysis, clean architecture and controlled implementation,
we make existing systems stable and ready for further development again.
Many companies work with software that has evolved over many years or even decades – for example in devices, machines, industrial systems or product-related systems.
As long as a system runs unchanged, it usually remains stable. It becomes risky when changes are necessary, but it is no longer clear what impact they will have.
Typical causes are:
- Dependencies between components are no longer fully transparent
- Architecture and codebase have grown organically over the years
- Tests do not provide reliable certainty about side effects
- Knowledge about the system is held by only a few people
Qwasaa helps companies modernize long-established software in a structured way without putting functioning systems at risk. This keeps existing software stable while making it reliably ready for further development again.
New features can be integrated again, interfaces can be extended and new device generations can be further developed without every change becoming a risk.
- Changes become predictable again
- Releases become more stable
- Codebases become easier to understand
- New features can be integrated safely
- Long-term further development becomes possible
When long-established software becomes a challenge
Many technical systems are developed over long periods of time. New features are added, technologies change and different developers work on the same system over many years.
Especially in fields such as medical technology, industrial automation, analytical devices or machine control systems, software often remains in use for 10 to 20 years.
As long as the system runs unchanged, it usually functions reliably. Challenges arise when changes become necessary – for example due to new features, device generations or interfaces.
Typical causes are:
- Dependencies between components are no longer fully transparent
- Architecture and long-established structures are difficult to understand
- Knowledge about the system is concentrated among only a few people
- Tests do not provide enough confidence for changes and releases
The result: changes become risky, releases are difficult to plan and new features can only be integrated with a high degree of uncertainty.
Qwasaa helps companies systematically analyze such systems and modernize them step by step.
The goal is not a complete rebuild, but a system that remains stable while once again being reliably ready for further development.
What companies gain from software modernization
When long-established software is restructured, it creates tangible benefits.
Codebases become easier to understand, dependencies become transparent and architectural decisions become easier to follow.
Changes can be integrated in a controlled manner without unexpected side effects.
Technical debt becomes visible and can be reduced in a targeted way.
New features can once again be integrated safely and existing systems can continue to grow.
Teams can implement changes more quickly because the structure and relationships within the system become clearer.
Knowledge about architecture and system behavior is documented and made available to the team.
Existing systems can be further developed without having to be rebuilt from scratch.
Qwasaa develops and modernizes long-lasting software systems where quality, safety and predictability are critical.
Software modernization
We modernize existing software systems step by step and in a controlled manner.
Instead of completely replacing functioning systems, we improve structure, architecture and development processes – in a way that keeps existing software stable while making it ready for further development again.
Typical steps
- Analysis of the existing codebase
- Structuring architecture and dependencies
- Reduction of technical debt
- Establishing stable and reproducible build and release processes
This keeps the existing system functional while making it understandable, maintainable and ready for development again.
In many long-lasting device systems, this also includes the further development of the user interface. These interfaces are often based on Qt, have been built over the years using Qt Widgets and C++, and reach their limits when new requirements arise, such as more modern UI concepts, current Qt versions or a clearer separation between the interface and system logic.
Qwasaa helps companies modernize such Qt applications in a targeted way, for example by migrating to current Qt versions or by transitioning from Qt Widgets to QML-based user interfaces (Qt Quick).
This keeps the existing device software stable while making the interface more modern, flexible and maintainable in the long term.
The migration from Qt 5 to Qt 6 in particular is complex in larger applications that have grown over many years – especially with extensive codebases, custom UI components and long-established build setups. To give companies more confidence in planning and implementation, we have put together a compact Qt 6 migration checklist. It helps maintain control over every step: analyze, migrate, optimize.
Download the migration checklist now
The migration to Qt 6 is in your hands, and with the right preparation it will be a success.
Technical software assessment
Many companies know that their software needs to be modernized. Most of them are unsure where to start.
A technical software assessment provides clarity here.
Qwasaa analyzes existing systems in a structured way and evaluates:
- Architecture and code quality
- Technical risks and dependencies
- Build and release processes
- Options for step-by-step modernization
The result is a clear technical assessment and a roadmap for how your software can be further developed in a stable manner.
Cyber Resilience Act (CRA)
Many manufacturers and product teams already know that they need to take action on the CRA. What many of them are still unsure about, however, is where to start and how to translate regulatory requirements into their product development in a practical way. At the same time, the CRA is not only a compliance topic. If approached in the right way, it becomes a lever to improve products structurally, for example through clearer responsibilities, robust security and update processes, better documentation, and more transparency regarding dependencies and risks.
Qwasaa supports companies in bringing CRA into an actionable sequence: from scope definition and product categorization to gap analysis, action planning, SBOM, documentation, and audit-ready processes.
Already our webinar “Compliance ohne Kopfschmerzen: What the Cyber Resilience Act really wants from you, and how it makes your product better” (in German only) and the strong response to it, showed how relevant this topic already is for many companies, and how useful it is to start now with a structured CRA approach.
Qwasaa roadmap for a structured CRA start
To give companies more confidence when getting started, we have put together a compact CRA roadmap. It shows how CRA can be approached in phases.
Download the PDF and see what a well-structured introduction to CRA looks like:
organized, manageable, and audit-ready.
Software development for devices and machines
Qwasaa develops software for product-related systems, especially user interfaces and applications in the context of devices and machines.
Software solutions we develop:
- Device software and user interfaces
- HMI applications for machines and industrial systems
- Visualization and operation of technical systems
- Interfaces to new systems and data platforms
New requirements often arise, especially in long-established systems: data needs to be made available for analysis, automation or AI applications.
We develop clean interfaces and integrations for this without destabilizing existing systems.
New features are integrated in such a way that they function reliably within the existing system and remain maintainable in the long term.
In doing so, we often work with technologies such as C++ / Qt or .NET, depending on the system architecture and application environment.
Integration and backend solutions with Symfony
Symfony development with PHP expertise from Qwasaa for high-performance, modular applications that integrate seamlessly into existing processes.
Qwasaa develops software for product-related systems with a particular focus on user interfaces and applications in the context of devices and machines. With our Symfony and PHP expertise, we create high-performance, modular web applications that adapt precisely to your requirements and integrate seamlessly into existing processes. The result is secure, maintainable and scalable solutions: from company portals and internal platforms to individual applications for your digital business processes.
Process digitalization and automation
In many technical environments, data is generated in different places:
- Machines and sensors
- Excel spreadsheets
- Local databases
- Paper-based test records
This information often exists, but is not centrally available or is difficult to evaluate.
Qwasaa helps make such data available in a structured way and gradually digitize technical processes.
This creates traceable data flows, fewer media discontinuities and a better basis for analysis, automation or new applications.
This often results in integrations and applications built around existing systems, implemented with technologies such as .NET or Symfony.
Software solutions for the following industries
Qwasaa primarily works with companies whose software remains part of a product for many years and must function reliably.
Medical technology
Software for medical devices must function reliably and meet regulatory requirements. Changes must be documented in a traceable way and integrated safely.
Industry & automation
Machine and device software often remains in use for many years and is continuously extended, for example through new features, interfaces or device generations.
Semiconductor industry
Production and analysis systems operate with highly precise device software that must run stably while also being further developed.
Aerospace
Software is developed over long development cycles and often remains in use for many years. Accordingly, the requirements for stability and maintainability are high.
How Qwasaa works
Software modernization requires a structured approach.
We analyze architecture, codebase and dependencies. This makes risks, technical debt and relationships within the system visible.
Improvements are made in controlled steps within the existing development line. Product development remains deliverable while the structure and architecture of the software are gradually improved.
Automated tests, reproducible builds and clear interfaces ensure that changes can be integrated safely.
Our goal is a system that your team can understand and continue to develop independently in the long term.
Qwasaa helps companies make changes to long-established device software predictable again.
The team behind Qwasaa
Software modernization requires experience in dealing with complex and long-established systems.
The Qwasaa team consists of experienced software developers, architects, testers, project managers and UX specialists with backgrounds in areas such as:
- Embedded software
- Device software
- Software for technical systems
- Digitalization of technical processes
- Long-term system architecture
Many of our team members have worked for years on software for devices and complex software systems, often in environments where stability, traceability and long life cycles are critical.
This experience helps us understand existing systems before we change them. Our aim is not only to keep software functional, but to make it sustainably ready for further development again.
A real-life example
A manufacturer of analytical devices was working with device software that had grown over many years. Over time, it became increasingly difficult to integrate new features. Changes often led to unexpected side effects and releases became increasingly unstable.
Qwasaa first analyzed the architecture, dependencies and the existing build system.
On this basis, the codebase was gradually restructured and key technical debt was reduced.
Result:
- More stable and more predictable releases
- Significantly improved maintainability of the software
- New features can once again be integrated more quickly and safely
Why companies work with Qwasaa
Companies work with Qwasaa on device software and complex software systems.
Typical reasons are:
- Legacy software needs to be modernized in a structured way
- Device software needs to be further developed or extended
- A technical assessment provides clarity about architecture and risks
- Software is needed for new devices or device generations
- Data from existing systems should be made available for new applications
Qwasaa helps companies make long-established software ready for further development and integrate new features reliably.
We work where software remains part of a product for many years and must function reliably in the long term.
First conversation
Understanding your system
In a first conversation, you walk us through your system and where things currently stand.
We typically talk about:
- How your system works today
- Where things are getting difficult or stuck
- What you want to improve or change
The call takes about 30 minutes. Afterwards, we both have a good sense of:
- What’s really going on
- Whether we can help
- And what a sensible next step would be
Creating clarity together -
the next sensible step for your software
These are your contacts
Frank Rub
Chief Executive Officer
Sebastian Kratz
Head of Innovation
Let’s get started
We look forward to your inquiry and will get back to you within one business day.
By clicking the submit button, you confirm that you agree to our privacy policy.
You can find us here
Our home is the 13th floor of the JenTower in the heart of the beautiful city of Jena on the Saale.
Feel free to stop by – we look forward to seeing you.
show on map