Company

From Copy/Paste to Intelligent Automation

2013, fresh out of university with a computer science degree, Stefan Pöter began programming classic PLC controllers for stage automation in his father's company. What he found there was symptomatic of the entire automation industry: Each project resembled the previous one – only the number of axes, the type of position sensing, or the load measurement configuration varied. The basic logic, motion control, control sequences – all were fundamentally identical.

Yet every new installation meant the same laborious process: copy the last project folder, manually adapt code, change variable names, go through axis configurations, and then – hopefully – test onsite at the customer's location. Reusability? Yes, but in the most primitive way: copy/paste followed by manual adaptation. No abstraction, no modularization, no systematic reusability.

And that's where the problem lay – a problem that still plagues the entire PLC world today.

While software development has made tremendous progress over the past twenty years – unit tests, continuous integration, automated end-to-end tests, version control with Git, code reviews, static analysis, refactoring tools – all of this has completely passed by the world of TwinCAT, TIA Portal and their ilk. These systems still work today much as they did in the 1990s. No automated tests checking if a change broke something. No simulation environments where you can run a complete system virtually before it goes live at the customer's site. No meaningful type system catching obvious errors at compile time. Quality assurance means: onsite commissioning, fingers crossed, hoping nothing unexpected happens.

And with these methods – methods that have long been considered obsolete in the rest of software development – systems are controlled today that cost millions of euros, where people work, and whose failure can cause five-figure losses per hour. If you step back and look at it objectively, it's almost inconceivable. As a computer science graduate who knew modern practices from university, this wasn't just too dull for him – it was simply too risky.

The Problem We Solve

Machine builders in small series are caught in a dilemma: Standard software doesn't fit individual customer requirements – flexibility simply isn't available. Custom development on the other hand blows the budget, because each project costs five figures and up, and when the next customer wants something different, the cost spiral begins anew. The third way – copy/paste of existing code – inevitably leads to maintenance chaos: bug fixes must be implemented in five different variants, tests and simulations don't exist, and quality suffers with each copied and manually adapted project.

Our Approach: Software Like for Large Series

Our framework makes small series economical – with the quality and reliability of large-series software. Concretely this means: the framework is built modularly and configurably, so customer requirements can be implemented without forking the software core. New axis required? Different sensor desired? That's a configuration matter, not a code fork that later becomes a maintenance nightmare.

Every change is tested and simulated before going live. Unit tests check individual components, end-to-end tests run complete system cycles, and in simulation environments the behavior can be virtually tested. We know what a change does to the code – before it goes to the customer, not after. The framework is reusable: developed once, it can be deployed any number of times, and updates benefit all installations. And it's continuously developed – we work daily with our framework and our customers' systems, so new features, optimizations, and bug fixes flow in continuously.

Multiple installations since 2013 benefit from this approach. The result: higher quality, more reliability, predictable costs – even with small quantities.

Our Business Model: Succeeding Together

Classic software service providers bill by effort, which creates a fundamental challenge for machine builders in small series: The project costs what it costs – completely independent of whether the machine ultimately succeeds or not. When it's unclear whether five or fifty units will sell, who bears the risk of a five-figure software investment? Typically, the machine builder alone, which leads either to the project not starting at all, or to cutting corners on software – with all the consequences for quality and maintainability.

We've developed a different model that resolves this dilemma: We develop as a partner company without upfront costs for you. The investment in initial development – adapting our framework to your specific machine, implementing your individual features, configuring it for your requirements – we initially bear. Our revenue comes when your machine is sold. Pay-per-machine instead of development flat rate – a model that only works because our framework already exists and has proven itself in numerous installations since 2013.

The core functionality – axis control, real-time communication, UI framework, safety functions – is already developed, tested, and proven in productive use. What needs to be newly developed for your project is limited to machine-specific adaptations and your individual features. This makes development time manageable and risk calculable for us, so we can afford to invest upfront. For you, this means: no high initial investment burdening your project budget, no uncertainty about whether software development pays off with small quantities, but predictable, quantity-dependent costs that scale with your success. If you sell five machines, you pay for five licenses. If it becomes fifty, it grows proportionally.

Long-term Partnership

This approach has a decisive consequence for how we work together: Service and support are not optional or an expensive add-on, but an integral part of the partnership. When your machine has problems at the end customer, that's immediately our problem too – because our business model depends on the machine functioning and you being able to sell more. Troubleshooting and problem solving are therefore a matter of course, and not just within the software: When the machine doesn't run as expected, we look at the overall system, help diagnose sensor errors, network problems, or hardware defects – even if the cause isn't in our software, because ultimately what matters is that the system runs at the customer's site.

In addition comes continuous development: Our framework is constantly evolving, new features emerge, performance optimizations are integrated, security updates deployed – and all installations, including your sold machines, benefit from this. When you're planning the next machine generation, need new features, or want to integrate different hardware, we think along, advise, and plan together, because we're invested long-term in the product and the partnership, not just in a single project. This is the core of our model: We share the risk. If your machine is successful, we are too. If it isn't, we've lost together. This creates a form of trust and alignment that rarely emerges in classic client-service provider relationships – we're truly pulling on the same string because our interests are structurally identical.

Who We Work For

Our ideal partner is the machine builder or engineer facing a specific challenge: They plan to sell their machine multiple times – but each customer has individual requirements, whether different sensor requirements, additional axes, special process sequences, or customized user interfaces that differ from project to project. Standard software can't meet these requirements and typically simply says: "That doesn't work." Custom development responds with the sobering calculation: "That costs X, and when the next customer wants something different, it costs Y again – and the one after that yet again." We say: "That's exactly our use case."

Our framework is built from the ground up to handle this kind of variability, not through endless configuration menus that ultimately don't cover all cases and themselves become a problem in their complexity, but through real flexibility in code – without having to fork the entire core for every customer request. When a customer request comes in, we extend the framework in the right places, and the next customer with a similar request already benefits because the extension has become part of the core and doesn't have to be maintained somewhere in parallel as a separate variant.

Industries?

We fundamentally address everyone who uses machines for production, manufacturing, or operation and faces the challenge that these machines aren't built as mass products but in smaller series with project-specific requirements. Stage technology was our origin – lifting platforms, hoists, turntables, all the complex mechanical systems used in theaters and concert halls. But the principle that works there can be transferred to many other areas: conveyor technology with variable routing that must adapt to different facility geometries; packaging systems that should process different product formats without building a completely new machine for each format; test stands for various component types that must be flexibly configurable; special machines for specific manufacturing processes that are built multiple times but never identically.

The commonality of all these use cases is that they're neither standard products rolling off the line in thousand-fold editions, nor true one-offs where everything must be reinvented each time, but something in between – small to medium series with significant variance between individual units, where both copy/paste and new development would be uneconomical.

Series Size?

The number of machines you plan to build plays a subordinate role in our model – whether it becomes five, twenty, or a hundred machines, our approach makes quality software economically viable even with small quantities. Anyone who previously thought "I can't afford proper, professionally developed software for five machines, I have to live with copy/paste" – for them we've developed a solution that hits exactly this sweet spot.

And should it turn out that the originally planned five machines suddenly become fifty because the product resonates better in the market than expected – all the better, for both sides: the framework scales effortlessly, costs remain predictable and grow proportionally to the number of machines sold, and quality remains consistently high because all installations benefit from the same updates, bug fixes, and improvements.