How Linearloop Built a Zero-Loss ERP for a Gold Refinery: Gold VGR ERP Case Study

When every milligram carries financial weight, manual tracking becomes a liability. VGR Gold needed more than a basic ERP. They needed a precision system that could eliminate manual gold tracking, digitise the entire refinery lifecycle, and ensure stage-wise traceability across melting, assaying, refining, casting, and recovery. The objective was to protect high-value assets through system architecture.

Linearloop built a refinery-grade ERP with a precision recovery engine at its core, designed to track residual particles, enforce controlled workflows, and provide real-time visibility across every stage. This case study breaks down how we engineered that system under tight constraints, extended platform capabilities, and delivered a zero-loss operational framework. Read on to see how we helped Gold VGR ERP move from manual processes to milligram-level control.

Read more: From Manual Coordination to Automated Logistics: Sarthitrans Case Study

VGR Gold is a Dubai-based gold refinery operating in a high-precision, multi-stage refining environment. Their workflow spans raw material intake, melting, assaying, refining, casting, and final recovery, each stage directly impacting weight, purity, and financial value. The business handles high-value material daily, where even microscopic discrepancies can translate into measurable loss.

The operating environment is accuracy-critical and regulatory-sensitive. Every batch must be traceable, documented, and verifiable across stages. Process deviations are not just operational issues. Instead, they carry financial and compliance implications. VGR needed systems that matched the precision of their physical operations.

Read More: Instream Case Study: Modernizing a Legacy CRM Without Downtime

Automation was not the goal. Precision was. VGR Gold needed a system that could account for every gram moving through the refinery, eliminate blind spots between stages, and replace manual reconciliation with system-enforced accuracy. The North Star was operational control at milligram-level fidelity.

• End-to-end gold lifecycle visibility: Every batch had to be traceable from raw intake to final recovery, with stage-wise status updates and complete historical records.
• Zero-loss tracking: The system needed to detect and calculate residual particles at each phase, ensuring no measurable gold went unaccounted.
• Real-time operational insight: Managers required live visibility into stage progress, weight changes, and recovery metrics without waiting for manual reports.
• Elimination of reconciliation gaps: Manual cross-checks between departments had to be replaced with system-driven validation and automated calculations.
• Controlled access and accountability: Role-based access controls were mandatory to ensure that each stakeholder could act only within their designated stage and responsibility.

The system had to be delivered fast, perform flawlessly, and operate in a zero-error environment. Engineering decisions had to balance speed with precision, without compromising traceability or security.

• 5-week delivery timeline: The entire ERP—across multiple refinery stages—had to be architected, built, tested, and validated within five weeks.
• No room for calculation error: Recovery calculations and stage-wise weight propagation required milligram-level accuracy. Even minor logic flaws could translate into financial loss.
• Performance under load: The system had to maintain consistency and responsiveness while handling simultaneous stage updates, image uploads, and reporting operations.
• Directus platform limitations: Several required workflows and calculation mechanisms were not natively supported, requiring custom extensions without breaking core stability.
• Security expectations: Strict role-based access control was mandatory. Each stage required controlled permissions to prevent unauthorised edits or data manipulation.

Read More: How Saffro Mellow Scaled with API-First D2C Architecture

Success was defined by operational trust. VGR needed a system that removed manual dependency, enforced accuracy at every stage, and created controlled visibility across the refinery lifecycle.

• Eliminate manual entries: Replace paper-based logs and spreadsheet reconciliations with structured, system-driven data capture across all refinery stages.
• Accurate recovery calculations: Ensure residual gold tracking and weight computations were precise, traceable, and automatically validated at every phase.
• Role-based access enforcement: Restrict user actions by stage and responsibility, preventing unauthorised edits and ensuring accountability.
• Stage-wise monitoring: Provide real-time visibility into batch status, weight transitions, and process progression across the entire lifecycle.
• Modular reporting flexibility: Enable dynamic, editable reports that reflect live operational data without compromising calculation integrity.

The complexity sat in the logic layer, where calculation errors, workflow gaps, or data inconsistencies could directly translate into financial risk. Every engineering decision had to protect traceability and precision.

• Residual gold recovery calculations: The recovery engine had to compute expected vs actual weight changes at each stage and track microscopic residual particles without rounding errors or propagation drift.
• Stage-dependent workflow logic: User actions and data visibility changed dynamically based on refinery stage, requiring tightly controlled transitions and validation checks.
• Multi-image compliance mapping: Each batch required multiple images tied to specific stages, stored, indexed, and retrievable without degrading performance.
• Data consistency across stages: Weight, purity, and batch data had to propagate accurately from intake to recovery, with no break in traceability.
• Extending Directus beyond native capability: Several refinery-specific workflows were not supported out of the box, requiring custom logic layers without compromising platform stability.

Read more: The Hidden Cost of Trade Discounts on Business Growth

The stack was selected for control, extensibility, and speed of execution. We used Directus as the operational backbone and extended it where refinery-specific logic required deeper customisation. The architecture remained lightweight but precision-focused.

The architecture was designed around one principle: trace every gram, at every stage, without breaking data integrity. Instead of layering features on top of a generic ERP, we structured the system around refinery flow, ensuring stage transitions, weight calculations, and reporting logic were deeply interconnected and scalable.

• Stage-aware data propagation: Each refinery phase right from intake, to melting, assaying, refining, casting, and recovery, everything was modelled as a controlled state transition. Data propagated with validation rules. Weight, purity, and batch metadata were locked, recalculated, and versioned at each stage to prevent silent discrepancies. This ensured traceability from raw material entry to final recovery without reconciliation gaps.
• Custom gold weight calculation engine: Standard ERP arithmetic was insufficient. We implemented a precision-driven calculation layer that computed expected vs actual weight differences, tracked residual particles, and maintained milligram-level accuracy. The engine validated inputs dynamically and prevented stage progression if inconsistencies were detected.
• Modular ERP structure: The system was built as independent but connected modules like order management, stage tracking, recovery, and reporting. This modularity allows future extensions (accounting, compliance modules) without disrupting the core refinery logic.
• Recovery module architecture: The recovery layer was designed as a standalone logic engine integrated with stage data. It recalculates residual quantities in real time and updates operational dashboards automatically, eliminating manual reconciliation.
• Real-time reporting engine: Reports are dynamically generated from live stage data. Editable interfaces exist, but core calculation logic remains protected to preserve accuracy and auditability.
• Mobile-friendly refinery interface: The UI mirrors physical refinery workflows. Operators can update stages on the floor without navigating complex dashboards, aligning digital execution with real-world operations.

Read more: Why Data Lakes Quietly Sabotage AI Initiatives

The timeline was fixed but the scope was complex. Execution required speed without sacrificing calculation accuracy or architectural integrity. We structured delivery around tight feedback loops and disciplined iteration to maintain control under pressure.

• Agile methodology: The project followed structured Agile cycles, breaking the refinery workflow into manageable build units aligned with stage transitions.
• Stakeholder check-ins: Regular syncs ensured validation of recovery logic, workflow behaviour, and reporting accuracy before moving to the next iteration.
• Iterative validation: Each module, especially recovery and stage tracking, was tested incrementally to detect discrepancies early.
• Rapid build cycles: Development and validation ran in parallel, allowing continuous refinement within the five-week window.
• Scope control within tight timeline: Priorities were clearly defined around precision and traceability, ensuring no deviation from core objectives.

Read more: How to Deploy Private LLMs Securely in Enterprise

The ERP replaced fragmented manual tracking with a centralised, stage-driven system. Every refinery phase now operates within a controlled workflow where data propagates with validation.

Manual logs and spreadsheet reconciliations were eliminated. Batch entries, weight transitions, and recovery calculations are system-enforced, reducing operational gaps and dependency on cross-verification.

Stage-level visibility is real time. Managers can track batch progression, weight evolution, and residual quantities instantly. The recovery module calculates residual gold at each phase and updates reports dynamically, ensuring milligram-level traceability.

The platform also creates a scalable base for Phase 2:

• Accounting integration
• Advanced compliance reporting
• Recovery enhancements
• Performance optimisation post-production

Live metrics will follow post-launch, but structurally, the shift is clear: Faster workflows, reduced waste, stronger retention accuracy, and tighter operational control.

Read more: RAG vs Fine-Tuning: Cost, Compliance, and Scalability Explained

The leadership team validated the recovery logic, stage transitions, and reporting structure during simulation cycles. They highlighted three areas of impact: 

• Clarity of workflow navigation
• Precision of residual calculations
• Confidence in system-enforced traceability

Operational teams responded positively to the stage-aligned interface. The workflow mirrors physical refinery movement, reducing friction during adoption. Role-based controls were particularly appreciated, as they introduced structured accountability without slowing execution.

We remain actively involved post-deployment. The engagement has transitioned from build phase to optimisation and expansion. Phase 2 is already structured around controlled enhancement rather than feature expansion for its own sake.

Phase 2 roadmap includes:

• Accounting module integration for financial alignment
• Advanced compliance reporting capabilities
• Extended recovery logic enhancements
• Performance tuning based on production load
• UI refinements driven by real usage feedback

GOLD VGR ERP demonstrates what happens when operational risk is addressed through system architecture. By replacing manual reconciliation with stage-aware workflows and milligram-level recovery logic, VGR moved from ledger-based tracking to a controlled, intelligent refinery platform. Precision became structural. Traceability became enforceable. High-value material handling is now backed by engineered accountability.

If your operations depend on accuracy, compliance, and zero-loss tracking, the solution is not another tool. it is architecture-first thinking. Linearloop builds systems designed for precision environments where mistakes are expensive. If you are ready to modernise critical workflows with the same level of control, let’s talk.