Poddie Ops (POPS) — A Full-Stack Operations Platform Built on the Edge
Poddie Ops is a custom, end-to-end operations management platform that runs an entire manufacturing business — from the moment a sales order lands to the day a modular office pod is produced, shipped, installed, and invoiced. It's built serverless-first on Cloudflare's edge network, integrates two external ERP/CRM systems (Katana MRP and Salesforce), and even gamifies the factory floor. One platform replaced a tangle of spreadsheets, manual hand-offs, and disconnected tools.
Role
Sole Architect & Developer
Stack
Cloudflare Workers, D1, Durable Objects, R2, React 18, TypeScript, TanStack Query, Vite, i18next
Scope
Backend, frontend, ERP integrations, infrastructure & ops
The Problem
Poddie manufactures modular office pods — configurable, physical products with dozens of options (exterior/interior colors, fire protection, sockets per country, furniture, monitors, and more). Running that business means orchestrating a long, branching chain of work: sales order → product configuration → serial-number assignment → multi-step production across two factory halls → logistics & route planning → on-site installation → invoicing & commission.
Each of those stages traditionally lived in its own silo — different spreadsheets, different people, no shared source of truth, and no real-time visibility. When something changed upstream (a delivery date, a configuration, a route), the information rarely reached the people downstream in time.
Poddie Ops was built to be that single source of truth.
The Architecture
Poddie Ops is split into two deployable sub-projects, both running on Cloudflare Workers:
- poddie-backend/ — a serverless API written in JavaScript on Cloudflare Workers, with 19 route handlers covering every business domain.
- poddie-frontend/ — a React 18 single-page app in strict-mode TypeScript, with 40+ routes across 16 feature areas.
Choosing the Cloudflare edge as the foundation was a deliberate bet: no servers to patch, global low-latency, and a tightly integrated data layer.
Compute
Cloudflare Workers (nodejs_compat) — zero cold starts, deploys in seconds, scales to zero cost.
Database
Cloudflare D1 (SQLite) — ~55 tables, 70+ versioned migrations, a real relational schema, not a key-value bolt-on.
Real-time
A Durable Object, PoddieLive, runs a single WebSocket hub fanning out across 6 channels.
File storage
R2 buckets for product images, documents, and screenshots.
Auth
Cloudflare Access (JWT) plus service tokens for enterprise SSO with an API-secret fallback for automation.
Scheduling
Cron triggers handle ERP sync every 10 minutes and automated DB backups.
A detail I'm proud of: 70+ sequential SQL migrations. The schema wasn't designed once and frozen — it evolved alongside the business, every change captured as a reproducible, ordered migration applied directly to the production D1 database. That discipline is what kept a fast-moving project maintainable.
What It Actually Does
Poddie Ops covers nine core business domains, each a fully-featured module:
- Orders & CRM — customers, contacts, addresses, order creation, and two-way Salesforce opportunity sync.
- Product Catalog — products, configuration options, add-ons, per-country pricing, and production-step definitions.
- Serial Numbers — automatic, prefix-based serial generation and assignment with full audit logging.
- Production — units, multi-step workflows across two factory halls, team and employee assignment, machine benchmarking, and live progress logs.
- Installation — a stops-based routing system with calendars, teams, trucks, and signed delivery documents (CMR/LS).
- Invoices — advance and final invoices, payment tracking, and sales commission.
- Inventory — stock management with reservation and sold-state tracking.
- Unified Inbox — tasks, forms, comments, and notifications in one place.
- Dashboard — KPIs and analytics across the whole pipeline.
The thread connecting all of these is real-time state. Through the PoddieLive Durable Object, a change made in production instantly reflects on the installation calendar, the dashboard, and any other connected screen — across channels for production, installation, orders, and per-user notifications.
The Hard Parts (and How They Were Solved)
Bi-directional ERP integration with Katana MRP
This is the kind of integration that quietly breaks businesses. Poddie's manufacturing data lives in Katana MRP, but the team needed Poddie Ops to be the master and Katana the slave — a single, authoritative catalog.
The solution: every catalog change in Poddie Ops (a new product, color, add-on value, or family) automatically triggers a background sync to Katana via Cloudflare's ctx.waitUntil(), plus a safety-net cron every 10 minutes. The sync maps Poddie's relational catalog into Katana's 15-group variant structure with a precise naming convention ("Product / model / version / color").
Two engineering decisions stand out:
- The sync only ever adds variants, never deletes them — protecting live sales orders from being orphaned by an upstream change.
- Graceful degradation: if the Katana API key is missing, the sync skips silently instead of throwing — the platform keeps working even when an external dependency is unavailable.
A schema that models a real, messy business
The 55-table D1 schema reflects genuine operational complexity — not a textbook example. Addresses are stored as immutable snapshots so historical orders stay accurate even when a customer moves. Serial numbers carry full provenance (manually changed by whom, when). Installation stops capture real-world details like elevator dimensions, building floor, and opening hours. This is domain modeling done by someone who understood the operation deeply.
Gamifying the factory floor
My favorite feature. To boost engagement on the production line, Poddie Ops runs a live Connect-4 game between production teams — every completed production step drops a token on a shared 6×7 board, with daily team pairings, cooldowns, and win detection. It's a small thing that turns routine work into a bit of friendly competition, powered by the same real-time WebSocket infrastructure as everything else.
A polished, human frontend
The React frontend isn't an afterthought. It's fully internationalized (German/English/Polish via i18next — important for a team spanning multiple countries), uses TanStack Query for robust server-state caching, and includes thoughtful touches like a personalized welcome screen with an online-colleague counter and a custom Vite plugin that auto-generates time-of-day celebration animations.
A standalone satellite service
Beyond the core platform, I built poddie-reports — an independent, single-file Cloudflare Worker for employee bug/improvement/change reports. It shares the same D1 database, has a public submission form (with honeypot spam protection) and an admin dashboard, handles screenshot uploads to R2, and pixel-matches the main app's design tokens — all with no build step. It demonstrates that the platform is an extensible ecosystem, not a monolith.
What This Project Demonstrates
For anyone evaluating my work, Poddie Ops is evidence of:
- End-to-end ownership — I architected, built, and operate the database, backend, frontend, integrations, and DevOps. There's no part of this stack I haven't touched.
- Serverless / edge-native engineering — real production use of Workers, D1, Durable Objects, R2, and Cloudflare Access, not a tutorial deployment.
- Systems integration — reliable, bi-directional sync with two third-party platforms (Katana MRP, Salesforce), with the failure modes thought through.
- Real-time architecture — a WebSocket hub built on Durable Objects that keeps an entire organization in sync.
- Domain-driven design — a 55-table schema and 70+ migrations that faithfully model a complex physical-manufacturing business.
- Pragmatic product sense — from immutable address snapshots to a Connect-4 game, decisions consistently balance correctness, resilience, and the human experience of the people who use the tool every day.
Takeaway
Poddie Ops took a manufacturing operation that ran on spreadsheets and manual hand-offs and turned it into a single, real-time, integrated platform — built on modern serverless infrastructure, and running in production today.