Insights into our maintenance work and product developmentOur Roadmap for Your Software: How We Plan, Develop, and Deploy Updates

Software updates are crucial for the security, efficiency, and feature set of our products. But how do we ensure that every update is a real step forward for our customers?

In this post, we open the doors to our planning process and show you how we ensure, from the initial idea to the final deployment, that our software updates are precisely tailored to our customers' needs. Learn how customer feedback drives development and how we ensure a smooth transition with every update.

1. Why Transparent Update Planning is Crucial

Software is never finished. Security vulnerabilities need to be closed, new requirements met, and existing features improved. Regular updates are therefore not a "nice-to-have," but essential for stability, performance, and security. Our standard: Transparency. We want our customers to know not only that an update is coming, but also why, when, and how it is being developed. In this post, we give you a look behind the scenes – from the initial idea and the internal roadmap to the final release. This includes not only new features and bug fixes, but also regular updates of third-party packages that are essential for security and stability.

2. Our Philosophy: Customer Feedback at the Core

Many new features start with an observation or a request from our customers' daily work.

• Our customers' voice matters: We collect feedback through tickets, direct conversations, or quarterly maintenance activity reports.
• From idea to feature: This feedback leads to concrete improvement suggestions that we discuss in the product team.
• Prioritization: Not every idea can be implemented immediately. We evaluate urgency, customer value, strategic relevance, and technical effort – this is how we ensure that the most important improvements are realized first.

3. The Update Roadmap: A Look at Our Plan

3.1 Update Categories

Our internal roadmap ensures that we balance short-term improvements with long-term visions. We adhere to the three types of updates defined by Semantic Versioning:

1. Major Updates: Major innovations, new core features, or a change to existing functionality.
2. Minor Updates: Optimizations of existing workflows, smaller new features. Existing functionality can be used as before.
3. Patches & Bugfixes: Quick bug fixes and security updates.

We use these categories for both internal developments and regular updates of the external packages we use.

3.2 Focus on External Packages

Our software is based on a variety of proven open-source libraries and external packages. To keep these components secure, performant, and compatible, we regularly check for new versions and update them promptly. For our customers, this means:

• Security Advantage: We close critical security vulnerabilities in external dependencies without delay.
• Less Coordination Effort: We usually implement minor and patch updates for such packages independently as part of the maintenance agreement – including testing and deployment.
• Plannable Major Updates: We coordinate larger version jumps that may require adjustments with our customers in advance and support them with staging tests.

This way, we ensure that the "invisible" parts of our software – the external packages – always remain up-to-date and secure, without our customers having to worry about it.

3.3 Prioritization & Timing

Updates from category 2 (Minor) and 3 (Patches) often have a smaller development scope; for external packages, no adjustments are often necessary. We therefore implement these updates at short notice and deploy them directly. Major updates, on the other hand, require more coordination. Often, our customers want to conduct extensive tests on the staging system after such updates before the update is deployed to the production system.

4. The Development Process: From Planning to Quality Assurance

Our teams work according to agile principles. In short sprints, we develop new features, test them, and flexibly adapt them to new requirements. Multi-stage tests – automated, internal, and by our customers on the staging system – ensure that new versions are stable and secure. In parallel, we carefully document every change so that functions are clearly explained and available in our knowledge base.

However, it should be noted that not every idea makes it into implementation immediately – resources, technical dependencies, strategic direction, and our customers' available budget play an important role. In the - hopefully long - life of a software product, it is completely normal for features or potential bug fixes not to be implemented, for example, because the implementation proves to be of low relevance.

5. Communication is Everything: Announcing Updates Transparently

We want our customers to never be surprised. Major updates, in particular, require more coordination. Both on our side, to be able to plan and reserve developer capacity, and of course on the customer's side, to have test capacity ready and to find a suitable deployment date. Smaller developments are also closely coordinated with our customers.

Only minor and patch updates of external packages are planned, carried out, tested, and deployed by us independently as part of the maintenance agreement.

For every update, there is a ticket in our ticket system. This is updated after deployment so that our customers always have insight into completed deployments.

6. Conclusion: Shaping the Future of Projects Together

Our update strategy is based on transparency, feedback, and quality. Our customers' input determines the direction in which the projects develop – and we ensure that every update arrives smoothly and well-documented for all customers.