ProcessMicroscope

Inspiration

Every stuck process leaves a trail, but most teams cannot see it.

Imagine Mike, a procurement operations manager at a growing manufacturer. A plant urgently needs a new supplier, but the supplier has asked four times when ordering can begin. Purchasing blames compliance. Compliance says the documents were incomplete. Mike's dashboard reports a four-day average, and the official process diagram shows a clean sequence of steps. Neither explains what happened to this supplier or where the process repeatedly breaks down.

The evidence already exists inside ordinary system histories: case IDs, activities, timestamps, and teams. Yet accessible dashboards usually summarize outcomes, while enterprise process-mining platforms can be too complex or expensive for smaller operations teams.

We built Process Microscope to close that gap: turn operational hunches into evidence, event logs into action, and departmental arguments into a shared picture of what actually happened.

What it does

Process Microscope is a browser-based operational X-ray. A user loads a simple CSV containing a case identifier, activity, timestamp, and optional resource or team. The app reconstructs the workflow that actually occurred instead of displaying only the workflow that was designed.

It reveals:

The real process map and every observed transition
The different paths—or variants—cases followed
Median and tail cycle times
Repeated-work loops and rework rates
Wait hotspots between recorded events
Filters that recompute findings for the selected evidence
Complete case traces for investigating individual exceptions

In our synthetic supplier-onboarding scenario, Process Microscope turns 1,183 events across 180 cases into six actual process paths. It reveals that 39% of cases contain rework, document requests repeat in 65 cases, and the interval from receiving documents to compliance review has a 2.4-day median across 83 cases. Users can compare straight-through onboarding at 3.3 days with a document-rework path at 6.1 days, then open a single slow case and inspect its exact sequence of events.

All analysis runs locally in the browser. The app uses deterministic calculations and carefully bounded language: it shows where teams should investigate without pretending to know why something happened.

How we built it

We built Process Microscope end to end in Codex with GPT-5.6 Sol.

Codex supported the full product-development cycle. We used it to explore and rank more than 60 hackathon concepts, pressure-test feasibility, define the minimum viable product, plan the architecture, implement the application, generate deterministic synthetic datasets, write tests, inspect the interface in a browser, iterate on the visual experience, maintain milestone commits, document the project, and prepare the deployment and demo story.

The application is built with React and TypeScript. Its client-side process-mining engine parses and validates event logs, orders events within each case, derives directly-following transitions, groups cases into variants, calculates cycle-time distributions, detects repeated activities and loops, identifies elapsed-time hotspots, and recomputes results as filters change. Seeded datasets make every demo reproducible, while automated tests verify the underlying calculations.

This was a human–AI collaboration. Codex accelerated implementation, iteration, and verification; we remained responsible for the problem definition, product scope, metric semantics, visual judgment, and final approval.

Challenges we ran into

The hardest challenge was not drawing a process map. It was making every number trustworthy.

Event logs contain many edge cases: unsorted rows, repeated activities, incomplete cases, simultaneous timestamps, inconsistent fields, and paths that differ by only one step. We had to establish precise definitions for cycle time, rework, variants, loops, and waits, then ensure the interface and filtering logic used those definitions consistently.

We were especially careful with elapsed time. A long interval between two events is evidence of a delay in the recorded process, but it is not automatically working time and does not prove a cause. The product therefore distinguishes observation from explanation and invites investigation instead of generating unsupported conclusions.

Another challenge was visual density. Process data can become an unreadable web of nodes, edges, metrics, and exceptions. We repeatedly simplified the experience so that a first-time user could move from overview to finding to individual case without needing to be a process-mining expert.

Finally, we had to balance ambition with the hackathon deadline. A disciplined scope, synthetic but realistic scenarios, automated verification, and frequent working milestones helped us reach a polished, deployable product rather than a collection of disconnected experiments.

Accomplishments that we're proud of

We are proud that Process Microscope is not a static mock-up. It is a complete, interactive application with a deterministic analysis engine and evidence that can be inspected down to an individual case.

We are particularly proud of:

Turning a specialist discipline into a workflow approachable by an operations manager
Keeping analysis private and responsive by running it locally in the browser
Recomputing metrics and findings when users filter the evidence, rather than merely hiding elements on a chart
Connecting high-level KPIs to variants, bottlenecks, loops, and auditable case traces
Building reproducible procurement, customer-support, and last-mile-delivery scenarios
Using tests and carefully bounded product language to earn trust instead of overstating what the data proves
Developing the product through a transparent sequence of meaningful Git milestones
Using Codex across discovery, engineering, testing, visual iteration, documentation, and deployment

Most importantly, the product replaces blame and guesswork with a shared body of evidence. That can change the tone of a real operational conversation.

What we learned

We learned that process visibility is not primarily a visualization problem. It is a trust problem.

Users need to understand where a metric came from, what it means, and what it does not mean. The most useful product does not announce a mysterious “root cause.” It lets a team move naturally from a signal—such as a high rework rate—to the affected path and finally to the exact event history of a real case.

We also learned how effective Codex can be as a development partner when the work is grounded in explicit constraints and continuous verification. It helped us move quickly between product thinking, code, testing, browser inspection, and documentation while preserving a coherent direction. The strongest results came from pairing that speed with human ownership of semantics, judgment, and prioritization.

Finally, realistic storytelling matters. “A 2.4-day median interval” becomes meaningful when Mike is trying to answer a supplier, unblock a plant, and replace a room full of opinions with evidence everyone can inspect.

What's next for ProcessMicroscope

The next step is to turn the focused prototype into a practical analysis workspace for growing operations teams.

We want to add reusable import mappings for common exports, stronger data-quality diagnostics, saved analyses, period-over-period comparisons, collaborative annotations, and shareable investigation reports. Calendar-aware duration options and configurable metric definitions would help teams adapt the analysis to their operational context without obscuring the raw evidence.

We also see opportunities for connectors to ticketing, CRM, ERP, warehouse, and workflow systems. These should preserve the product's local-first and privacy-conscious principles wherever possible.

AI could assist with field mapping, plain-language guidance, and hypothesis generation, but deterministic evidence must remain the foundation. Any suggested explanation should be clearly labeled, traceable to the underlying events, and presented as something to investigate—not as an invented fact.

Our long-term goal is simple: give any operations team an accessible first microscope for the processes they already run.

Process Microscope. See the process you actually run.