TrakHound Docs TrakHound Framework Architecture for Plant Teams

Architecture for Plant Teams

How TrakHound differs from typical microservices, and why it suits internal teams in enterprise and industrial environments.
Framework Docs Menu

Large software companies often split their systems into microservices: many small services, each with its own deployment pipeline and infrastructure, run by dedicated platform teams. Manufacturers usually don't have those teams. Their software is built by engineers in manufacturing, quality, and maintenance, supported by a small IT group, and it has to run for years on plant networks. TrakHound keeps the parts of microservices that help those teams, small modules that are versioned and deployed on their own, and puts the infrastructure every module needs into one host, the Instance.

Typical microservices
Service A
ContainerPipelineAuthLogsMetricsHealth
Service B
ContainerPipelineAuthLogsMetricsHealth
Service C
ContainerPipelineAuthLogsMetricsHealth
Platform Orchestrator, API gateway, service mesh, and observability stack, run by a platform team
TrakHound
Instance
QualityPackage
AndonPackage
OEEPackage
Built in once, for every Package
RoutingSecurityZonesLogs MetricsHealthAdmin UI
Plant engineers and IT A Windows or Linux server, with Packages installed from a Package server
Each microservice carries its own copy of the infrastructure. TrakHound Packages share one Instance that provides it.

Built for the Teams That Run a Plant

Software in a plant is built and run under different conditions than at a software company:

  • Builders are engineers first - Manufacturing, process, quality, and controls engineers write tools for their own areas, alongside their other work
  • IT is small and stretched - A few people support every department's systems, with no platform or site reliability team
  • Networks are isolated - Plant networks are often locked down or disconnected from the internet, so cloud services and public registries aren't always available
  • Software runs for years - A tool written today must still run, and still be understood, long after the person who wrote it has moved on
  • Changes must be validated - Process owners need to try a change before it reaches production, and some industries require a record of what was approved

Compared with Microservices

Typical microservicesTrakHound
Unit of deployment A service, usually a container image A versioned Package (an API, App, Function, Worker, Service, or Identity provider)
Where code runs Each service in its own process or container Packages from every team run in an Instance, each loaded in its own assembly load context with its own dependencies
Security, logging, metrics, and health Built into each service, often with shared libraries or sidecars Provided once by the Instance: security profiles, Zones, logs, metrics, health checks, and CPU by Module
Data access Each service connects to its own databases and brokers Modules call Services, and Routers set by IT decide which database or broker answers, so modules don't need connection details or credentials
Deploying a change A pipeline builds an image, pushes it to a registry, and the orchestrator rolls it out Install the new Package version from the admin UI, the CLI, or a Deployment, while the Instance keeps running
Rolling back Redeploy the previous image Every installed version stays side by side, so Revert switches back to the previous one
Infrastructure Orchestrator, API gateway, service mesh, container registry, and observability stack A Windows or Linux server running the Instance (see Installation), and a Package server shared by every Instance
Who runs it A platform or DevOps team Plant engineers and IT, from the browser-based admin UI
Scaling Run more copies of a busy service Run more Instances, for each plant, line, or role, and connect them over HTTP
Isolation A service has its own process, memory, and CPU limits Modules share the Instance's process. Zones limit what each can reach, and a module that needs its own process can run in a separate Instance or a standalone host

What a Shared Host Gives Plant Teams

  • Engineers write only their logic - An API or Function is a small class. Hosting, routing, sign-in, logging, and metrics are already there, so modules stay small and quick to review
  • IT manages one platform - One place for security, updates, monitoring, and credentials, instead of a different system for every department's tool
  • Every team's modules look the same - Modules share one structure, data interface, and deployment process, so engineers can support modules written by other departments
  • Teams build on each other's work - Modules call each other's APIs and Functions and read shared data through Services, instead of copying data between systems
  • Nothing to assemble first - There is no orchestrator, gateway, or observability stack to set up before the first tool goes live, and it all works on an isolated network
  • A clear record of what runs - Each Instance lists the Packages and versions it runs, and the same Package file moves from test to production (see Development, Test & Production)
  • Safe ground for new code - Zones limit what modules in development, or written with AI tools, can reach through the Instance

Scaling Out with More Instances

One Instance can run many modules, and organizations grow by adding Instances rather than splitting each module into its own service. Every Instance installs from the same Package server and is managed the same way.

  • By environment - Separate Instances for development, test, and production
  • By plant or line - An Instance at each plant, or for each line, so a problem in one doesn't affect the others, and modules that only use local data keep running when the network between plants is down
  • By role - Separate Instances for operator Apps, data collection Workers, or modules that need more CPU or memory than the rest
  • Connected over HTTP - The TrakHound.Http.Service Package routes Service calls to another Instance, so a plant Instance can read and write data held by a central one, and modules call other Instances' APIs like any HTTP API
  • Monitored like any server - /_health and /_health/live suit load balancers and monitoring tools (see Health Checks)

Where Microservices Still Fit

Microservices make sense when many independent development teams release on their own schedules, when parts of a system need to scale far beyond the rest, and when a platform team is in place to run the infrastructure. TrakHound works alongside them:

  • TrakHound APIs are ordinary HTTP endpoints with OpenAPI documents, so corporate systems can call them, and modules can call corporate services (see API Catalog & Explorer)
  • Code in other languages can call an Instance over HTTP (see Other Languages), and a Package can run a Python or Node.js process that calls the Instance as that Package with a Module Token, so its Zone still applies
  • An API, Worker, or Function can also run on its own in a standalone host, such as a container or cloud web app, without changing its code
  • A common split is corporate systems such as ERP in the data center, and TrakHound Instances on the plant floor for the tools engineers build and change often

Trade-offs to Know

  • Modules share a process - A module that uses a lot of CPU or memory affects the others on the same Instance. CPU by Module shows which module is using the server, and busy or critical modules can move to their own Instance or a standalone host
  • Modules are .NET - Packages are built with .NET. Other languages call the Instance over HTTP or run in a process a Package starts
  • Modules follow the Instance's version - Packages are built against the TrakHound version of the Instance they run on, or an older one, so plan Framework upgrades across Instances

Next Steps