Custom Manufacturing Software Development: OT/IT Integration Architecture, Team Ratios, and Project Cost Brea…

Why COTS Manufacturing Software Breaks on the Plant Floor

Commercial off-the-shelf (COTS) Manufacturing Execution Systems (MES) and enterprise ERPs promises turnkey shop-floor visibility. In practice, they hit an expensive wall the moment they touch physical hardware. Modern plants rarely run on single-vendor, uniform infrastructure. A typical factory floor combines 20-year-old CNC machines running serial Modbus, 10-year-old Siemens S7 PLCs, and newer Allen-Bradley ControlLogix units communicating over EtherNet/IP.

COTS vendor platforms handle standard workflows well, but they charge enterprise licensing fees ($200k+ annually) while kicking protocol bridging back to your engineering team. When you need custom scrap-tracking logic, direct PLC-driven line stoppages, or low-latency local telemetry during WAN outages, off-the-shelf software requires extensive vendor customization or fragile intermediate database middleware.

Building custom manufacturing software isolates core operational logic from vendor lock-in. Instead of adapting your plant operations to fit rigid SaaS workflows, custom software constructs a lightweight, event-driven data bus around your actual physical hardware. When legacy systems stall innovation, engineering leads turn to legacy system modernization strategies to untangle monolithic software and wrap air-gapped equipment in modern APIs.

OT/IT Architecture: Bridging Industrial Protocols to Modern Cloud Networks

Connecting Operational Technology (OT) to Information Technology (IT) requires an architecture that treats industrial hardware failures as normal network events. OT operates on deterministic, millisecond-level execution cycles; IT operates on eventual consistency and REST APIs. Dropping an HTTP request directly onto a plant network can lock up an unbuffered machine interface.

A production-grade OT/IT integration architecture separates hardware ingestion, protocol translation, message broker queuing, and business logic into isolated tiers.

Protocol Ingestion and Edge Gateways

Edge gateways reside on local physical subnets, communicating directly with Programmable Logic Controllers (PLCs). The gateway converts native industrial protocols—such as OPC UA, Modbus TCP, BACnet, and EtherNet/IP—into standardized data payloads (typically JSON or Protocol Buffers).

Store-and-Forward Data Resilience

Factory Wi-Fi and industrial Ethernet drops happen constantly. If an edge worker cannot reach the central server, it must write sensor records to a local disk (e.g., SQLite or RocksDB) and resume streaming once connectivity returns. Without store-and-forward architecture, your Overall Equipment Effectiveness (OEE) metrics will show artificial downtime spikes whenever network hardware power-cycles.

High-Throughput Edge Ingestion

When processing thousands of high-frequency sensor events per second at the edge, resource consumption on industrial PCs becomes a constraint. In telemetry-heavy, low-latency edge deployments, choosing between memory-managed runtimes and low-level systems languages impacts board costs and thermal limits. Teams evaluating language choices for low-footprint edge collectors should read our analysis on whether you should rewrite performance-critical services in Rust.

Cost Breakdown by Scope ($120k–$500k)

Manufacturing software pricing varies based on hardware complexity, network isolation, regulatory audit needs (e.g., FDA 21 CFR Part 11), and the number of distinct PLC types involved. Below is a breakdown of realistic budgets across common manufacturing modernization scopes.

Where Budget Goes Wrong

• Underestimating PLC driver integration: $30,000 eaten up writing custom driver wrappers because legacy PLC controllers lack open OPC UA interfaces.
• Ignoring operator usability: Building a desktop web app for plant operators who wear heavy gloves or work under high ambient glare.
• Scope expansion on ERP synchronization: Assuming NetSuite or SAP REST endpoints perform reliably under high-frequency batch updates without custom middleware queuing.

Engineering Staffing and Team Ratios

A standard web development team will fail on a factory floor. They write code assuming reliable internet, standard REST interfaces, and zero physical safety hazards. A balanced engineering allocation for a $250,000 manufacturing software build looks like this:

• 1 Lead Systems Architect (0.5 FTE): Sets OT security boundary, defines MQTT/Kafka topic hierarchies, designs data models for high-write telemetry, and manages ERP integration patterns.
• 1 Senior Embedded / OT Engineer (1.0 FTE): Knows PLC memory mapping (registers, coils, DB tags), configures industrial gateways, writes edge protocol adapters, and tests hardware signal behavior.
• 1 Full-Stack Backend Engineer (1.0 FTE): Constructs time-series data pipelines, REST/GraphQL APIs, authentication, role-based access control (RBAC), and enterprise system integration.
• 1 Frontend / UX Engineer (0.5 FTE): Designs high-contrast, touch-optimized Human-Machine Interfaces (HMIs) for shop-floor displays and administrative management dashboards.
• 1 QA / Field Automation Test Engineer (0.5 FTE): Simulates lost packets, hardware disconnects, corrupt payload signals, and high-concurrency operator input load.

This structure delivers roughly 3.5 Full-Time Equivalent (FTE) resources per sprint, keeping monthly burn rates between $40,000 and $65,000 over a 5-to-7-month development cycle.

Managing Plant-Floor Risks: FAT, SAT, and Air-Gapped Security

Deploying custom software to a live production line can stop an entire shift if handled like a standard web deployment. Software releases must follow industrial validation methodologies.

Factory Acceptance Testing (FAT)

Before any code runs near physical machinery, engineers build a virtual plant model. Using software simulators (such as PLC programming software or custom mock servers), the dev team injects simulated tag data, high-rate alarm loops, and corrupted network packets. FAT ensures business logic, time-series ingest engines, and database persistence operate safely under artificial load.

Site Acceptance Testing (SAT)

SAT takes place on the physical plant floor during scheduled maintenance downtime or slow shifts. Code runs against real machines under strict human supervision.

1. Read-only validation: Connect edge collectors and confirm tag reads match physical machine states without transmitting control signals back to PLCs.
2. Disconnection drills: Pull network cables from edge nodes mid-stream to verify store-and-forward buffering prevents data loss.
3. Control loop verification: If the software issues commands back to the line (e.g., triggering a gate reject), test with dry runs before running live product.

Purdue Model Network Compliance

Plant networks follow the Purdue Model for Industrial Control Systems (ICS). Custom software usually spans Level 2 (Control), Level 3 (Operations Management), and Level 4 (Enterprise IT). Your backend software must respect dual-homed networks and firewall DMZs. Direct database queries from a cloud server down to a Level 2 PLC subnet are unacceptable; all traffic must traverse secure proxy brokers in the DMZ.

Implementation Timeline: 24 Weeks from Audit to Go-Live

A typical custom MES or OT/IT integration project spans six calendar months when executed with dedicated domain engineers.

1. Weeks 1–4: Protocol Audit & Network Architecture Inspect plant floor networks, catalogue target PLCs, confirm tag lists, audit ERP endpoint capacity, and document ISA-95 interface requirements.
2. Weeks 5–10: Edge Gateway & Protocol Ingestion Build low-level protocol drivers, implement local buffer persistence, and validate zero-data-loss behavior over simulated network dropouts.
3. Weeks 11–16: Core Application & ERP Connectors Implement OEE metrics engines, scrap reporting logic, time-series telemetry storage, and event-driven ERP integration connectors.
4. Weeks 17–20: HMI Touchscreens & Operations Dashboard Deliver touch-optimized interfaces for machine operators, floor supervisors, and plant managers. Run FAT with mock PLC signals.
5. Weeks 21–24: SAT, Parallel Run, & Production Handover Deploy hardware gateways onsite, execute SAT scripts during scheduled downtime windows, run parallel metrics collection alongside manual log sheets, and complete operational handover to plant engineering.

What This Means for Your Team

Modernizing manufacturing software does not require ripping out functioning machinery or paying millions in annual enterprise SaaS fees for rigid COTS tools. Custom engineering gives you full control over your operational data, eliminates manual shift reporting, and bridges legacy industrial hardware directly to your core enterprise systems.

By keeping scope tight, isolating protocol drivers at the edge, and enforcing strict FAT/SAT deployment practices, an engineering team can deliver production-grade plant software for $120,000 to $500,000 without risking production line uptime.

If you are planning an OT/IT integration project or replacing a legacy shop-floor application, get in touch with our team to review your plant floor architecture and get a firm estimate.