Superseded · See ArcSuite

ArcV2 System

The command center and rule engine that became ArcSuite — where the JDE overlay pattern, the flag-based rule model, and the delivery roadmap were all worked out.

Role
Architect & developer
Stack
.NET · C# · Avalonia
Domain
Architecture & design phase
Status
Superseded by ArcSuite
arcv2-system main window
Main window
1:1 JDE overlay relationship
Flag based rule engine
0 writes to JDE data
This is the earlier version

ArcV2_System is the design-and-build phase that preceded the production suite. The live apps — BOM Report Tagger, OpsTool, Digital Cubby, and the tracked print library — are documented on the ArcSuite page. What's interesting here is the architecture that got carried forward.

The architectural decision that mattered

The most consequential thing this phase produced was the JDE overlay pattern.

Instead of writing workflow state back into the ERP, the system splits data into two layers with a strict relationship:

LayerNaturePurpose
JDEReportRead-only, immutable snapshotThe ERP data as it was, never modified. A stable source of truth.
ArcReportMutable overlay, 1:1 with JDEReportAll Arc-specific workflow state, kept entirely separate from the ERP record.

The value is data integrity. You never have to wonder whether a field reflects what the ERP says or what someone's workflow did to it — the two are physically different records. And when the ERP snapshot refreshes, the overlay survives because it was never part of it.

That pattern is the backbone of the production ArcSuite, where a shared database serves four applications.

Design principles established here

  • Flags over statuses. Track requirement and completion as separate domains rather than collapsing them into one status field. A part can be required-but-not-done, or done-but-not-required, and those are genuinely different states.
  • No hard locks — warn instead of block. The only place that gates anything is the Digital Cubby, because plate nesting and printing genuinely shouldn't happen twice. Everywhere else, the system tells you what it thinks and lets you proceed.
  • Audit everything. Every state change produces a history entry, so "why is this like this?" always has an answer.
  • Single source of truth for work orders and BOM lines.
  • Multi-level priority (0–10) on a work order, which elevates every related task in every list — so priority is set once and respected everywhere.
Warn, don't block

This is the principle I'm most glad I kept. A shop-floor tool that refuses to let someone proceed when they know something the software doesn't will get worked around immediately. Warning preserves the operator's judgement while still surfacing the risk.

Domain model

The phase defined the entities the production system still uses:

  • Production_Flags — per-domain requirement and completion state.
  • Status_History — the audit trail of every transition.
  • Packages — the persistent database entity representing a unit of shop work.
  • Tasks — the user-facing term for a work queue item, corresponding to a Package.
  • External Work, Print Queue, Alerts, and Priority — supporting concerns that each got their own model rather than being squeezed into the package record.

The rule engine

A meaningful portion of this phase went into a rule engine that assigns requirements, handles external work, and generates date-aware alerts. It's also where a known performance problem lived: rules evaluated against stored state rather than in memory.

The identified refactor — evaluate rules in-memory and return history entries rather than round-tripping per rule — was noted here and resolved in the production suite, where user-defined tagging rules classify an entire BOM on import without a recompile.

Delivery roadmap

The milestone structure defined in this phase carried directly into the production work:

MilestoneScope
M1Snapshot ingest — build and maintain the JDEReport snapshot from JDE.
M2Overlay data layer — ArcReport and WorkOrderArc tables, plus the write service.
M3Ops Tool creation and execution flow — file-first task creation for plate, pipe, and linear-feet work, with shop execution tracking.
M4Command Center management layer — triage, priority, rule execution, reporting.
M5Print queue with reprint warnings and external work management.
M6Priority system — bulk elevate, sorting, chips, history, permissions.
M7Omniwin verification trust workflow — partcode vs. drawing validation.
M8Inventory and release evaluation — requisition signaling and release readiness.

Explicitly out of scope

The phase also drew firm boundaries, which is why the production suite stayed focused:

  • Analytics and BI beyond operational dashboards — export to a real BI tool later instead of building one.
  • Structural drafting flow — shop-driven only, no Cubby involvement.

UI suites designed here

The Avalonia application laid out the suite's shape: a PO processor for PDF ingest and PO-to-work-order mapping, an Ops Tool for pipe packages and plate nestplan triage, and the Arc command center with an Omega dashboard, notifications, print queue, admin tools, logs, and priority elevation.

The live ArcSuite implements all of it in WPF, with the same responsibilities distributed across the same four apps — which is the clearest evidence that this phase's architecture held up in contact with production.

Success criteria, revisited

The project defined its own success criteria before building: deterministic shop queues, accurate flags, full traceability, zero duplicate nesting or printing, fast exception handling, and clear expedited paths via priority.

That list is essentially a description of what the production suite now does, which is the best thing I can say about this phase. It wasn't built to be shipped — it was built to find out what should be.

Related projects