Building an ERP System from Scratch

Building an enterprise resource planning (ERP) system from scratch is widely regarded as a corporate software nightmare. Legacy off-the-shelf platforms like SAP and Oracle offer massive feature sets, but their archaic licensing models, inflexible database architectures, and six-figure custom integration consulting fees often strangle high-growth manufacturers.

When a 200-person precision manufacturing enterprise approached Binary Froster with specialized multi-stage assembly lines that commercial ERPs could not model, we designed a custom, greenfield solution built for ultra-fast throughput and total architectural autonomy.

1. Architectural Blueprint: The Decoupled Core

Rather than building a brittle monolith, we isolated the system into three distinct layers:

• Transactional Core: High-performance Node.js microservices with tRPC providing compile-time type safety across the wire.
• Storage & Isolation: PostgreSQL running on managed AWS Aurora with serialized transaction isolation to prevent double-booking of physical raw materials.
• Operational Frontend: Next.js App Router with optimistic UI updates and offline-first IndexedDB synchronization for ruggedized factory floor barcode scanners.

2. Preventing Inventory Race Conditions with Redis Mutexes

In high-volume manufacturing, two automated assembly lines frequently attempt to reserve raw components simultaneously. Relying on basic SQL UPDATE queries inevitably causes overselling and inventory negative balances.

We engineered a dual-layer locking mechanism: an ephemeral Redis Redlock distributed mutex for rapid request gating, followed by a strict SQL SELECT ... FOR UPDATE lock inside a serializable database transaction:

// lib/inventory/allocator.ts - Strict Distributed Inventory Allocation
export async function reserveStock(batchId: string, quantity: number, orderId: string) {
  const lockKey = `lock:inventory:${batchId}`;
  const lockAcquired = await redis.set(lockKey, orderId, 'NX', 'PX', 5000);

  if (!lockAcquired) {
    throw new Error('Concurrent allocation in progress. Please retry.');
  }

  try {
    return await prisma.$transaction(async (tx) => {
      // Row-level lock on the specific stock batch
      const stock = await tx.$queryRaw<StockRecord[]>`
        SELECT id, available_quantity FROM inventory_batches
        WHERE id = ${batchId}::uuid FOR UPDATE
      `;

      if (stock[0].available_quantity < quantity) {
        throw new Error('Insufficient batch allocation remaining.');
      }

      await tx.inventory_batches.update({
        where: { id: batchId },
        data: { available_quantity: { decrement: quantity } }
      });

      return await tx.stock_reservations.create({
        data: { batchId, quantity, orderId, status: 'RESERVED' }
      });
    }, { isolationLevel: 'Serializable' });
  } finally {
    // Release distributed lock safely via Lua script
    await redis.eval(RELEASE_LOCK_LUA, 1, lockKey, orderId);
  }
}

Results and Return on Investment

Within six months of deployment, the manufacturer eliminated over £180,000 in recurring SaaS licensing fees, reduced raw material wastage by 28%, and cut average order dispatch times from 3 days to under 4 hours.