OpenCore MES Try the demo
The problem

Growth means downtime and a bigger server.

Every change a maintenance window; every new line a hardware purchase; the shift-start burst slows everything down.

Solution

Changed while it runs

  • An approved change goes live when its executor says: no deploy, no window.
  • Open screens redraw by themselves; nobody signs out.
  • A new release restarts the servers; the database upgrades itself as they start.
Solution

More servers, not a bigger one

  • Add servers behind a balancer; every screen stays live.
  • Read replicas take the reads, never showing stale data.
  • Any server can stop without losing anything.
  • Asked for more than it can do, a server says so at once and keeps its pace.
  • A role taken away holds on every server from the next request.

Measured, not promised.

200 lot moves a secondon one server: a move is one lot through one step, four transactions each checked, audited and committed; p50 16 ms, 225 with four worker threads for the rules
200 moves a second on four serversnone refused, none behind; 175 a second on one along a wafer fab's CMOS route, p95 under 125 ms
3 hours, 226,000 movesa server's memory flat throughout, at 28 MB
1,000,000 lotsa move still takes 22 ms, p95 under 50; any lot found by its label in 1 ms, a page of the list in 3 ms
140–160 moves a secondmachine moves on four servers, the database on another host 1 ms away
30,000 peopleadded in one approved change; one found in 12 ms
3,000 station screens, liveeach open on a machine of its own (seven blocks, one a number over the whole plant), on four servers at 50 moves a second: a move takes 24 to 32 ms, p95 under 75
40 people, one live listread once for the crew, not once each: a move in 29 ms where it took 830 ms
59 statements a movedown from 136: four transactions, each checked, audited and committed whole
Asked for 250, it does 230a server asked for more moves a second than it can do goes on doing what it can and tells the rest it is busy before doing anything; after a burst it is back at its usual latency within 20 seconds
0.5 s for one transactionat p95 during that burst when those told busy come back later, where it was 1.2 to 2.5 s; a page asks again by itself
15 % of a move's timeis about what hash-chaining the audit trail and sealing every record cost, when a plant turns them on
60 moves a secondon one process of an 8-vCPU cloud VPS, four transactions each, the database at 7 ms of work a move and never the limit
600,000 audit entriesre-hashed and verified from the first in 7 seconds
9 KBwritten to the database's log by one transaction, down from 14: the record, its audit entry with before and after, its indexes

For scale: a 300 mm fab starting 50,000 wafers a month in lots of 25, on a route of 1,000 steps, makes about 2 million lot moves a month, under one a second on average and many times that at a shift's start. Measured on one laptop: PostgreSQL 17 at its default memory, with group commit and compressed page images (the settings a plant runs with), its WAL allowed to grow to 8 GB; the lot moves an open load through the same API the screens use. The VPS figure on an 8-vCPU KVM instance with PostgreSQL 16, the same load, before the latest round. Your hardware will differ.

Solution

Built on Juris.

A framework made for real-time, data-driven systems; it ships inside, nothing else to install.

  • Layout is dataA designed screen is stored, versioned and drawn at once.
  • Live queriesOnly what changed is sent, once per shared query.
  • Light on memoryOnly the open tab is in the page: the others are drawn again when opened, with what was typed still in its fields.
  • Quiet when hiddenA browser tab left in the background stops its updates, and catches up when looked at again.
  • No build stepNo bundler, no runtime dependencies.
  • Safe by defaultMarkup that could run code is refused.
Solution

Plain JavaScript, few dependencies.

Less to install, less to patch, less to go wrong at three in the morning.

  • One language. JavaScript modules on Node and in the browser: no TypeScript, no bundler, no build step.
  • The same code twice. A page drawn on the server is the one the browser runs; a form's checks run in both.
  • Node and PostgreSQL, nothing else. No message broker, no cache server: the servers share the database.
  • Five direct dependencies. The database driver, Juris (none of its own), charts, a PDF viewer and the copilots (with the Claude SDK).
  • Readable in place. What runs is what is in the repository, line for line.
  • Older browsers welcome. Safari 15.4, Chrome 93, Firefox 92.

Why JavaScript?

The browser speaks it

One language from the database to the button: a page is drawn on the server and taken over by the browser, with no second version of it to keep in step.

Your engineers read it

The language most developers already know. A plant's own rules and services are JavaScript too, so whoever writes them can read the platform beneath.

Designs are its data

Screens, forms and rules are stored as plain objects, which JavaScript reads as they are: nothing to compile between an approval and the screen.

Fast enough to measure: the figures above are this JavaScript, on Node. Its standard library serves the web, signs and hashes, and runs the plant's scripts in workers of their own, so few packages are needed besides.