Seth Ramsey

Operator UX runs on a tablet connected to the edge device. Admin UX runs separately for configuration, blade and material management, and multi-tenant administration. A development-mode sensor bridge lets the platform run without physical hardware during testing.

Screenshots

Evolution

V1 was edge-only with no cloud sync. Raw streams recomputed at query time. V2 added incremental normalization, bidirectional sync, multi-protocol adapters, multi-cell support, and a server-rendered frontend.

Bidirectional Sync

Two data types, two strategies. Telemetry flows edge → cloud only with high-water-mark sync. Configuration flows both directions with last-write-wins per record. Devices ship pre-configured and field-deployed, then sync once online — or get updated remotely. Per-field merging looks cleaner but operators edit settings as a coherent set; splitting fields would create behavior they don't expect.

Bandwidth at the Edge

Edge devices often run on cellular with limited bandwidth. V1's HTTP/JSON was wasteful — verbose payloads, no compression. V2 uses gRPC with Protobuf packing and stream compression. Significant bandwidth reduction without losing schema clarity.

Universal Protocol Adapter

V1 was Bluetooth-only with hardcoded sensor characteristics. V2 needed to handle whatever protocol came next — OPC-UA, Allen-Bradley, Siemens. Built a common gRPC ingestion endpoint that accepts pre-formatted SawLink data. Adapter pods translate from native protocols and push to the endpoint. Adapters deploy on a device or on a separate machine — wherever the network terminates. Core platform doesn't know about specific protocols.

React → Templ

Years of Go ↔ JSON ↔ React translation overhead. Tried OpenAPI codegen. Tried ORMs. Each layer added maintenance burden without removing the underlying problem. Moved to Templ + HTMX — same Go app that ingests data and syncs with cloud renders HTML directly. The Linux device hosts its own WiFi network that the operator tablet connects to, so the UI has no cloud round-trip. Snappier loads, better behavior in disconnected operation.

Origin

Co-op project that grew from a Python script. Started by scraping a Fanuc robot's status page for one engineer. Tied in camera replays on faults, added operator downtime tracking, then PLC integration, then plant-wide rollout. Made the case for it as a co-op, delivered V1, joined full-time pre-graduation. Ran the project to 50+ machines.

Architecture

V1 polled machines from a front-office VM. Fragile — data gaps during network outages. V2 moved ingestion onto small Linux devices networked directly to equipment on the plant floor, including equipment on offline networks.

Edge Ingestion

Each machine speaks its native protocol. Each edge device runs a Python pipeline — connect via protocol library, normalize, sync to backend via write-ahead HTTP. Tag files give Python the flexibility to transform raw values into the right format. New equipment means a new tag file, not new code.

Write-Ahead HTTP

Plant floor networks are unreliable. Each outgoing HTTP request appends to a local file. A drain process sends it to the backend and removes it on success. Survives outages, reboots, and backend downtime without data loss.

Lifetime Counters and Raw Recording

Tried shift tallies, weekly counts, per-part counts. Every fixed aggregation broke when someone asked for a new window. Switched to monotonic lifetime counters: any window becomes count(end) - count(start). Fixed aggregations still exist for commonly queried logs — they rebuild from the counters, and any window stays arbitrarily queryable in the future. Raw data recording handles measurements like press temperatures where the values matter, not just the counts.

Read Scaling

Many clients poll at one-second intervals. Recomputing aggregations on read doesn't scale. Cache updates synchronously on writes — when a data point arrives, only the affected windows recompute. Polling clients read from the same cached result. Reads stay O(1) regardless of client count.

Stack

Backend went from Python to Go for static typing and single-binary deployment. PostgreSQL with TimescaleDB replaced an early MongoDB experiment. Python stayed at the edge. Continues to run in production via a ZeroTier overlay for administration.

Problem

Existing deployment processes for restricted environments typically involve multiple manual steps — archive extraction, dependency installation, image loading, helm setup. Wanted something faster, cleaner, and operable in one command.

Pattern

A pack tool runs online and produces a single self-extracting binary that handles installation offline.

Pack: A manifest declares the helm charts, K3s version, and plugins. The pack CLI reads the manifest, automatically pulls the images defined in the helm charts, compresses an asset archive, and appends it to the install binary. Output is one deployment file.

Install: Operator runs ./install. Binary extracts its appended assets, installs K3s, loads container images into containerd from the archive, and applies the helm charts. containerd shares images between nodes.

Engineering Decisions

• Declarative pack manifest. Users describe what they need; the tool creates one file that deploys it.
• OCI image archive. Standard format, loaded directly into containerd without an intermediate registry.
• Shared codebase for pack and install binaries. Pack CLI and install CLI are separate binaries built from the same Go codebase — shared primitives, distinct entry points.
• Same install binary acts as a runtime CLI. Can execute without extracting, so the deployer and application tooling can ship in one artifact.

Built for a friend running his own shop. He was on paper — asked for help. Built a full quoting workflow with nested assemblies, mixed labor types (fixed and variable), material costing with markup, and a quote lifecycle from received through submitted. Calculations and fields auto-populate; a formatted PDF pops out and gets emailed to customers. Data in SQL, React frontend, deployed to a VPS.

Screenshots