blessed_moon@studio
studio: Blessed Moon Studio
founder: Benito Pedro Xavier · Solo studio
discipline: Strategy · Design · Engineering
stack: Next.js · Tailwind · WebGL
scene: ASCII moon · 5 keyframes
type: Space Grotesk / JetBrains Mono
accent: #ff6a1f
sound: muted
status: ready
B / S / MCASE_18 / 26

— Case study 18

Plexus

The edit made by hand on one photo is the exact pipeline that runs across five hundred

All work
plexus.capture● verified
Plexus editor with an image loaded, the Light / Color / Sharpen controls on the right and a live WebGPU preview of the current recipe

project overview

An extensible media-processing engine with a non-destructive, WebGPU photo editor on top, built so the recipe assembled by hand on a single image is the exact pipeline definition a Go worker runs, unmodified, across a whole folder — live preview in the browser, full-resolution execution on the backend, one data structure behind both.

shipped outcome

A working system where dropping a photo into the editor and dragging Light, Color and Sharpen feels instant with no server round-trip, and 'apply to batch' runs that exact recipe as a real DAG pipeline across a whole folder — with live per-step progress and no worker able to silently lose a job. The gRPC plugin contract, which lets a third party add a processor in any language without touching the core, is deliberately phased last because it is additive to an already-working engine, not a dependency of it.

Role
Solo architecture and full-stack development
Timeline
2026 — feature-complete case study
Year
2026
Team
Solo
The problem01

A fixed pipeline — upload, one transformation, download — is a demo, not infrastructure. Nothing in the portfolio behaved like a general-purpose, extensible media engine: the kind of thing a Cloudinary or a Zapier-for-media actually has to solve. And engineering-first tools like that usually expose their internals — queues, jobs, DAGs — directly in the interface, which reads as powerful to their author and unapproachable to the person dragging a slider.

The approach02

Plexus is built around one idea: an edit made by hand on a single photo and a batch pipeline definition are the same data structure. Every editor control writes to a small ordered list of processor-and-parameter steps — a recipe — instead of touching a pixel. That recipe previews live in the browser over WebGPU (with a WebGL2 fallback), and the identical recipe is what a Go worker executes, unmodified, whether it is one image or five hundred. NestJS owns the pipeline DAG resolution and the job state machine; Go owns the CPU-bound ffmpeg and libvips work; NATS JetStream is the one piece of infrastructure behind both job dispatch and the real-time progress stream the front-end subscribes to.

The result03

A working system where dropping a photo into the editor and dragging Light, Color and Sharpen feels instant with no server round-trip, and 'apply to batch' runs that exact recipe as a real DAG pipeline across a whole folder — with live per-step progress and no worker able to silently lose a job. The gRPC plugin contract, which lets a third party add a processor in any language without touching the core, is deliberately phased last because it is additive to an already-working engine, not a dependency of it.

— Interface evidence

The product, not a placeholder

These are the verified interface captures from the project build. Scroll inside taller frames to inspect each complete page.

Plexus home — drop a file, or choose photo, video or audio to start01 / 08
Plexus home — drop a file, or choose photo, video or audio to start
The quick-actions menu: photo, video and audio entry points02 / 08
The quick-actions menu: photo, video and audio entry points
Photo quick actions — edit, convert, or compress03 / 08
Photo quick actions — edit, convert, or compress
Video quick actions — shrink, convert, or extract audio04 / 08
Video quick actions — shrink, convert, or extract audio
Audio quick actions — convert to MP3, WAV or AAC05 / 08
Audio quick actions — convert to MP3, WAV or AAC
The non-destructive editor before an image is loaded06 / 08
The non-destructive editor before an image is loaded
The editor with an image loaded, previewing the recipe live over WebGPU07 / 08
The editor with an image loaded, previewing the recipe live over WebGPU
The jobs page — batch runs in progress and completed, with per-step progress08 / 08
The jobs page — batch runs in progress and completed, with per-step progress

— Delivery process

From operating constraint to shipped system

The work is sequenced around risk. Domain rules and failure states come before interface polish; automation arrives before handoff.

01

Core pipeline engine

The orchestrator, one Go worker type, Postgres and NATS — linear pipelines only, with built-in resize, convert and compress processors for image, video and audio. No editor yet; the point was proving a job could be dispatched, run and tracked reliably.

02

Editor MVP

The non-destructive recipe model, the WebGPU/WebGL2 live-preview renderer, and the curated composite sliders — Light, Color, B&W, Sharpen, Crop — with synchronous export. Shippable as its own milestone, independent of the batch machinery.

03

Real DAGs, realtime and Apply to Batch

Presigned MinIO upload, the shared recipe package, an SSE progress stream off the same NATS events, and branching, parallel DAG resolution — the point where 'edit once, apply to five hundred files' became a real button instead of an architectural claim.

04

Plugin system — not started

The gRPC plugin contract that lets a third party add a new processor in any language without touching the core. Phased last on purpose: it is additive to an already-working engine, not something the engine depends on.

— System architecture

Clear boundaries, explicit responsibilities

Each layer has one job and a narrow contract. That keeps external services replaceable and product behavior testable.

Next.jsTypeScriptNestJSGoWebGPU / WebGL2NATS JetStreamPostgreSQLMinIO
plexus.syssystem schematic

recipe / one shape

editor = pipeline

one photo by hand = 500 in batch

steps

[ { processor, params } ]

●go runs the same recipe

engine / guarantees

webgpu preview · no round-trip[x]
apply to batch (real dag)[x]
sse progress off nats[x]
crash-safe dispatch[x]
grpc plugins[ ]
edit once → dag → go workers → export
Client

Next.js + WebGPU/WebGL2 editor

Upload, dashboard, live progress and the in-browser non-destructive preview renderer — no pixel ever leaves the browser during editing, only the recipe.

API

NestJS orchestrator

Auth, pipeline DAG resolution and the job state machine: queued, running, partial, complete or failed.

Async

NATS JetStream

A persistent, replayable event log backing both job dispatch to workers and the SSE progress stream to the browser — one piece of infrastructure doing two jobs.

Workers

Go worker pool

ffmpeg and libvips-backed built-in processors, horizontally scalable, executing the same recipe at full resolution for export and batch runs.

Storage

PostgreSQL + MinIO

Drizzle-managed jobs, pipelines, recipes and plugin registry in Postgres; presigned-URL upload and download through MinIO so the API never proxies large files.

— What shipped

Product capabilities

01

Non-destructive recipe editing

Every control — crop, light, color, sharpen — writes recipe parameters, never pixels. Undo and redo are just recipe history.

02

Live WebGPU preview

Slider drags render in the browser with no server round-trip, falling back to WebGL2 where WebGPU is unavailable.

03

Apply to Batch

The recipe built by hand on one photo runs, unmodified, as a pipeline across an entire folder of files.

04

Real-time job progress

Per-step progress over SSE, driven off the same NATS event stream used for dispatch, not a separate polling loop.

— Engineering pressure

Challenges resolved

01

Preview-to-export fidelity drift

The browser's WebGPU approximation and the Go server's ground-truth render must agree closely enough that export never surprises. Drift per composite control is measured numerically against a bound and enforced by a test, not checked by eye.

02

Crash-safe job dispatch

A worker killed mid-job must not silently drop it. JetStream's persistence, plus explicit ack and heartbeat handling, means another replica picks the message back up instead of the job vanishing.

03

A language boundary that stays a contract

With Go and TypeScript on either side of gRPC, NATS subjects and a shared Postgres schema, the boundary is easy to let dissolve into ad-hoc JSON. The recipe schema has exactly one canonical definition, and everything else imports or generates from it.

verified project destinations

next case studyReelcast

next transmission

Need a system this deliberate?

Bring the operating problem. We will shape it into a clear product brief and a buildable next step.

Start a project