Company
About ootb automation GmbH
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.
Our Development
The Beginning: Experimenting and Learning
Stefan Pöter set out to take the few good aspects of TwinCAT and TIA Portal – mainly their support for industrial fieldbuses like Profibus and EtherCAT – and re-implement them in a modern software environment. The first stage controller written in C++ wasn't just functional, it was fundamentally different in conception: the code was modularly structured, divided into reusable components, and above all – testable. Individual functions could be tested in isolation, motion sequences simulated, edge cases explored, all without requiring an actual machine to be connected.
The framework grew with each project. New requirements emerged – different motor types, additional control logic, more complex motion profiles – and the system didn't become more chaotic, but more robust. Tests caught regressions. Refactorings improved structure without destroying functionality. With each project it became clearer: what was emerging here wasn't just a better solution for stage automation. It was a framework for machine control in general – applicable wherever precise motion control and real-time requirements come together.
In parallel it became clear that there was no reason to start from scratch every time for user interfaces either, or to bind ourselves to proprietary panel manufacturers. Browser technology – HTML5, WebGL, WebSockets – had become powerful enough to realize high-quality industrial UIs. From 3D visualizations of machine movements to complex process displays and live data streams. The advantage: the UI runs everywhere. On the panel at the machine, on the service technician's tablet, in the production manager's browser. No special hardware required, no binding to one manufacturer, updates via browser without firmware flash.
The Step to GmbH
After years as a freelancer, during which the framework continuously grew and proved itself in more and more installations, Stefan Pöter founded ootb automation GmbH in February 2021 – initially alone. At that point the framework was mature. The technical foundation stood on solid ground. Dozens of installations were running productively, the architecture had proven itself in practice, the advantages over classic PLC solutions were obvious. He had understood how to build modern automation solutions that aren't just functional, but also maintainable, extensible, and scalable.
But the first years as a one-man GmbH also revealed the limits of what a single person can achieve – even with the best technology. Being technically good isn't enough to make a company successful. Sales is its own craft. Marketing requires expertise and continuous work. Network building takes time, presence, strategic thinking. All things that a developer who prefers writing code and solving technical problems doesn't bring to the degree necessary. Projects ran, the framework continued to develop, technically everything went well – but growth remained well behind what would have been possible with the existing technical foundation.
The Team Completes Itself
2024 was the year the puzzle completed itself. Peter Luck and Konstantin Schrader joined as co-founders. Finally the lesson that should have been learned years earlier: Without partners who bring complementary strengths, enormous potential remains untapped. An important insight that had been suppressed for too long. Today Stefan Pöter and Peter Luck lead the company together as managing directors, bringing different, complementary perspectives – technical depth on one side, strategic business thinking on the other.
We can do a lot technically – that was never the problem. But running a company, building a brand, nurturing customer relationships, developing sales channels, forging strategic partnerships – all that requires skills, experiences, and perspectives that go far beyond software development. Today we work not only as a management team, but also with a network of experienced freelancers and shareholders who bring specific expertise. We employ modern development methods, not just in software, but also in company management. And we deal openly with mistakes and learnings – internally and externally. Reflection and continuous improvement instead of perfectionism facade.
The Team
Today, Stefan Pöter and Peter Luck lead ootb automation as managing directors. Stefan brings the technical expertise and over ten years of experience developing the framework. Peter contributes strategic business thinking and sales experience. Together with Konstantin Schrader as shareholder and a network of experienced freelancers, they form a team that combines technical excellence with entrepreneurial thinking.
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.
Over 30 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 over thirty 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.
Let's Talk – Without Sales Pressure
You're planning a machine series and wondering if classic control software is really the only option? If copy/paste and manual adjustments really must be the state of the art? If quality software really is unaffordable for small series?
We say: No.
We offer a non-binding conversation. No sales pitch, no standard presentation. Instead: We listen. You tell us about your machine, your challenges, your plans. We honestly say whether we're the right ones for it – or not.
Sometimes standard software is actually the better choice. Sometimes custom development makes more sense. And sometimes – when flexibility, quality, and economy must come together – we are the right solution.
We'll find out together.