The hours you don't spend are the job's margin
Nobody quotes tag mapping as a line item. It gets absorbed — into the estimate, into the schedule, or into somebody's evening.
The work is not difficult. It is just long, and it repeats: name a tag, name a column, check the data type, do it again. A single wide event — a check-in record, a genealogy write, a recipe — can run to hundreds of members. Multiply by every event on the line, then by every controller, and the configuration is no longer a task inside the project. It is the project.
Then the customer changes a structure in week nine, and you audit all of it again.
One structure. One event. Whatever it carries.
Event Engine® works at the level you already engineered at. The UDT you built in Studio 5000, or the data block you built in TIA Portal, is the unit of exchange with the database — imported whole, kept in sync by re-import, and mapped once.
Configuration
Define the structure once. Use it everywhere.
Configuration effort scales with the number of structures, not the number of tag members.
Import the definitions straight from the controller — .L5X for Rockwell Logix; .scl, .stl, .db or .udt for Siemens S7. The imported types are compiled and held in namespaces, so types from different programs never collide. Where an import isn't appropriate, define the structure in the browser instead and reuse it the same way.
A 100-element array of a 10-member structure is one definition, not a thousand entries. A single structure tag carries its own trigger members, payload members, completion code and status message — so one tag is the whole contract between the controller and the event.
When the structure changes on the PLC side, re-import it once and every instance is covered. No tag-by-tag audit.
Members matched to parameters by name
Point the event at a stored procedure and the structure's members are matched to its parameters by name. Point it at a table instead and they match to columns the same way. What you are checking is the exceptions, not the mapping.
Write-back
The recipe round trip, in one operation
Reading a structure out is half the job. Most integration work is the half that comes back.
An Event Engine® event returns a database result set directly into a PLC structure of matching shape — including an array of structures. Pull the recipe rows from SQL and they land in the recipe array in the controller, in one operation, with no item-by-item target mapping and no script to maintain.
One event can return several variable-length result sets at once, each to its own destination. And every event closes the loop: a completion code, a status message and a timestamp written back to the controller, so the PLC program knows the record landed rather than assuming it.
- Structured read — the whole UDT or data block out of the controller in as few operations as the protocol allows.
- Structured write-back — the result set into a matching structure, shape for shape.
- Single write — payload and completion code consolidated into one write, removing a round trip.
Event types
Two things you would otherwise be scripting
Label printing and email are not integrations bolted onto a database tool here. They are event types, configured the same way as everything else.
ZPL label printing
A parameterised ZPL command string sent to any installed or network printer, driven by tag values — and the printer itself can be chosen by a tag, so one event serves a line of label stations. No reporting module, no print server, no scripted socket write.
Message notification
A parameterised SMTP message to the recipients you choose, with live process values embedded in the body. A machine faults and maintenance gets the fault, the part, and the values that produced it.
Both sit alongside the two database event types — stored procedure, and direct table read or insert — and all four share the same triggers, the same tags, the same diagnostics.
Across jobs
What you build on this job, you take to the next
A configuration you cannot move is a configuration you rebuild.
- Export and import individual items as JSON — move a working event, tag or structure between systems without recreating it.
- Back up and restore the whole configuration as a ZIP — clone a commissioned machine's setup onto the next one off the floor.
- Duplicate an event — the second station on a line costs a copy and a name.
- Three languages in the interface — English, Spanish (es-MX) and German (de-DE), chosen per Windows user. The plant that receives the machine reads it in their own.
Nothing is stored in a proprietary black box: configuration lives as JSON files on disk, which is what makes backup, restore and migration straightforward rather than a support call.
Build one on your own bench
Thirty days, fully functional. Take a wide event you have already built somewhere else and build it again here — the honest comparison is the one you run yourself.
Footprint
Nothing to deploy but Event Engine®
A Windows service that hosts its own web interface. There is no separate web server to configure and no platform underneath it.
No SCADA gateway to stand up, secure, patch and learn before the first transaction runs. No ODBC layer to install and tune on every host. No fat client on an engineering workstation, and no VPN session to check on an event — the interface is a browser on the plant network, with role-based access mapped to Windows or Active Directory groups.
That matters on handover as much as on install: what you leave behind is one service and one URL.
And the controller you can't drive natively
Logix, S7 and Modbus TCP/IP have native drivers, and that is the fast path. Everything else reaches Event Engine® over OPC UA — a legacy platform, a third-party device, a machine that came with the line. The event configuration is identical either way: same structures, same triggers, same write-back, same diagnostics. You are never quoting two integration approaches for one plant, and you are never telling a customer their odd controller is out of scope.
Commercials
Quote it once. Stop counting tags.
Event Engine® is licensed by event count, in tiers — not by tag.
A 22-member check-out event and an 859-tag recipe event cost the same, because they are both one event. That is the difference between an estimate you can stand behind at proposal time and one that moves every time the customer adds a member to a UDT.
Tiers stack, so a line that grows buys more events rather than a different product. Perpetual or subscription, with an annual maintenance agreement available on perpetual licences.
| On the job | Tag-mapped middleware | Event Engine® |
|---|---|---|
| Configuring a wide event | Every member mapped by hand | Import the structure; members matched by name |
| A 10-member structure × 100 instances | 1,000 entries | One definition |
| Customer changes the structure | Tag-by-tag audit, every controller | Re-import once, all instances covered |
| Recipe download to the controller | Target items mapped, or scripted | Result set into a matching structure |
| Printing a label | Scripting or a reporting module | A ZPL event |
| Emailing on a fault | Scripting or an alarm module | A message event |
| Second machine on the line | Rebuild the configuration | Export, import, rename |
| What you install | Platform, then the transaction layer | One Windows service with its own web UI |
| Licensed by | Tags | Events, in stacking tiers |
Downloads
Take it to your bench
The installer, the full documentation, and the commercial terms — so you can price the job and prove the claim without waiting on anybody.
- Event Engine® — 30-day trial — fully functional, no credit card, no sales call
- Event Engine® Overview (PDF) — the short version, for circulating
- Event Engine® User’s Guide (PDF) — every screen, and what each option does to the running system
- Event Engine® EULA (PDF) — the licence terms, before you have to ask for them
- Annual Maintenance Agreement (PDF) — support and upgrade coverage
Requires Windows, SQL Server or Oracle, and a PLC or OPC server.
Also worth reading
What your customer will ask about
The plant does not buy configuration time. They buy what happens at 2 a.m. three years from now — and they will ask you about it before they sign.