Home / Zeugwerk / Services / Training
Services

Training

Bring Git, review, CI, and testing to your automation team - practices that fit TwinCAT, real machines, and how your shop actually ships.

The gap nobody talks about

Most automation teams are built around control engineers and PLC programmers. What they rarely have is exposure to the software engineering practices that the rest of the industry has been running for twenty years: structured version control, automated testing, continuous integration, documented architecture, code review.

Not because they lack the ability. Because nobody in their world has shown them how these things work in practice - on real machines, under real project pressure.

The cost is invisible until it isn’t. A single engineer leaving takes the project knowledge with them. A regression reaches the machine floor because there was no automated test to catch it. A new hire spends three months learning the project before they can contribute. These are not bad-luck events. They are structural problems with a known fix.

What makes this different

We are not a training company with a fixed curriculum. We are engineers who build machines and maintain production code every day. We teach the underlying practices first - version control, CI/CD, software architecture, testing strategy - and we show where our tools fit in, and where they do not.

We work through real examples from your own codebase wherever possible. Abstract exercises built around toy problems rarely survive first contact with production code.

A team that finishes our training knows how to build a proper development workflow from scratch - independently of any specific vendor or toolchain.

To give you a sense of what we cover

2-day on-site workshop · from €1,900 plus travel. Remote delivery is available.

Topics, depth, and examples are scoped to your team in a short call before anything is scheduled. The outline below is a representative starting point - some engagements go deeper on software architecture and never touch our tooling at all.

Day 1 - Foundations

  • Structured PLC software: coding conventions, managed/unmanaged objects, library layering
  • Core concepts: object lifecycle, error propagation, the Bridge Pattern for decoupling equipment from HMI communication
  • Equipment objects in practice: actuators, I/O, axes - instantiated from tested building blocks, not reimplemented each project
  • Hands-on: building and integrating a framework object from scratch against a running demo machine

Day 2 - Application architecture and tooling

  • Standardised application structure: separating communication, data, and function - and why it makes codebases readable for engineers who did not write them
  • Unit architecture, state machine lifecycle, and how units coordinate without direct coupling
  • Sequences: step-based patterns, the Await helpers that replace polling loops, error propagation up the call chain
  • Tooling in practice: IDE scaffolding, commissioning without HMI code, backup/restore, CI/CD basics
  • Hands-on: completing the demo machine end-to-end

Get in touch → to discuss scope, team size, and format.

What we cover

Version control and Git workflows

Not just the commands. Branching strategies, commit discipline, pull request workflows, and how to structure a TwinCAT repository for a real team. We work through realistic scenarios until the workflow becomes second nature.

Continuous integration and CI/CD

What a build pipeline actually does, why it matters, and how to build one for TwinCAT from scratch. Automated builds, unit tests, artefact management, and deployment. Where it fits, we show how zkbuild, zkdoc, and zkbindings integrate - but the principles come first.

Software architecture for automation

How to decompose a machine into maintainable units, define interfaces between components, and handle state, errors, and logging in a way that holds up in production. We use the Zeugwerk Framework as a concrete example - but the concepts transfer to any framework.

PLC programming and TwinCAT

IEC 61131-3 structured text, OOP patterns, function block design, library management with Twinpack, and patterns for sequences, state machines, and equipment abstraction. We go as deep as your team needs.

The full stack beyond PLC

MQTT, OPC UA, REST APIs, databases, and C# ADS clients - the full stack connecting a PLC runtime to cloud services and operator interfaces. Teams that understand this build their own integrations rather than waiting for someone else.

Code review and engineering culture

Hands-on review sessions using your own codebase. We teach what to look for, how to give useful feedback, and how to set up a review process the team will actually use.

Zeugwerk Framework and Creator

For teams adopting our own toolchain: architecture, state machines, sequences, equipment configuration, simulation, and incremental adoption into an existing project. Creator: code generation, Snippets, Backup & Restore, documentation generation.

On-site or remote Format
Your codebase Real examples, not toy problems
Scoped per team No fixed curriculum

What to expect

Training is scoped to your team's situation in a short call before anything is scheduled. We agree on the topics, the format, and the depth - then deliver it.

If two days on-site covers what your team needs, that is what we scope. If you need an ongoing embedded programme over several months, we do that too.

With Zeugwerk Framework and Creator we were able to commission our prototype within a few days and test first sequences. Developing PLC software without a solid framework has become unthinkable since adopting the Zeugwerk suite.

Johannes Mandler - Fibionic GmbH
Training is scoped to your team in a short call before anything is scheduled. Tell us your team size, current stack, and what you are trying to improve.
Request a training programme →