Workflow

Editorial Workflow System

A multi-tenant editorial publishing platform where teams design review pipelines on a drag-and-drop canvas, offload PDF generation through a durable message queue, collate articles into structured journal issues, and loop in external reviewers via secure tokenized email links.

🏢 iKomet Technology Solutions2025

🔒 Source & live demo not available — built under NDA

About the Project

Built at iKomet Technology Solutions as part of Flowskoler — a full-stack publishing workflow platform — this module gives editorial teams a visual canvas to define their own review pipelines without any engineering involvement. Each stage is independently assignable with configurable routing conditions and TAT deadlines.

PDF generation is offloaded asynchronously via a durable RabbitMQ queue — decoupling the Express API from the PDF rendering service and allowing the UI to poll status independently while the job is processed in the background.

Extended the platform with an Issue Collation module — a TypeScript five-step wizard where editors aggregate articles by journal acronym, configure dynamic front and back matter via JSON-driven form schemas, and trigger PDF generation through a multi-stage approval workflow.

Added a Supporting File Validation pipeline as a dedicated background process — a RabbitMQ consumer calls the file server to validate figures and equations against the HTML source, writes the validation results back to the workobject, and routes to either the next stage or a recoverable error state where editors upload corrections and trigger revalidation.

Introduced external reviewer access without requiring system accounts — when the workflow reaches an external step, a UUID token is generated, a branded HTML email is dispatched via Nodemailer, and the reviewer lands on a secure page to download the proof, upload revised files to MinIO object storage, and submit structured feedback. Each round snapshots the proof PDF to MinIO for a versioned audit trail. A scheduled job triggers TAT-based reminders at 40% and 80% of the deadline window, with auto-advance on expiry.

Claude (Anthropic) was used as a productivity aid throughout development — accelerating boilerplate, debugging complex flows, and thinking through architectural decisions. All features were designed, implemented, and owned end-to-end.

Core Concepts

🔀

Visual Workflow Builder

React Flow canvas lets admins wire up review stages, branching conditions, and assignee routing — no code changes needed to define or modify a pipeline. Custom node types per process category with connection validation at draw time.

📨

Async PDF Generation Queue

PDF generation jobs are published to a durable RabbitMQ queue with persistent messages, decoupling the Express API from the rendering service. The UI polls a status endpoint while the job processes independently.

🔄

Multi-stage Review Flows

Content moves through configurable stages with per-stage assignees, ALL/ANY approval semantics, TAT deadlines, and full transition audit trails captured on every state change.

📋

Issue Collation Module

TypeScript five-step wizard where editors select articles by journal acronym, group and reorder them via drag-and-drop, configure dynamic front/back matter from JSON schemas, and generate a versioned publication PDF through an approval workflow.

🗂️

Supporting File Validation

A RabbitMQ consumer orchestrates the validation pipeline — calling the file server to cross-check figure and equation counts against the HTML source, writing results back to the workobject, then routing to the next stage on success or an error state on failure. Transient errors retry up to 3 times with 30-second delays; permanent errors (missing files, 4xx responses) are classified and dropped immediately.

🔗

External Reviewer Access

UUID token generated per step instance, stored against the email in DB, and served on a public route protected only by token middleware. Nodemailer dispatches branded emails; reviewer-uploaded files and proof snapshots are stored in MinIO, giving each review round a versioned record of exactly which proof was reviewed. A CronJob drives TAT-based reminders and auto-advances expired tasks.

Key Challenges & Solutions

Challenge: Idempotent and Concurrency-Safe Workflow Transitions

Ensuring workflow stage transitions remain consistent under network retries and concurrent edits, preventing duplicate advances and conflicting state changes.

✓Solution: Designed idempotent transition APIs using optimistic locking (versioned updates) to guard against concurrent modifications and duplicate retries. Conflicts return a 409 response, enabling safe re-fetch and retry.

Challenge: Dynamic Form Rendering for Issue Configuration

Each journal acronym had different front matter and back matter requirements — hardcoding separate forms per journal wasn't scalable as new journals were onboarded.

✓Solution: Stored form schemas as JSON configs linked to each journal acronym. The frontend reads the config and renders sections, toggles, and field types dynamically — adding a new journal requires only a new config entry, no UI changes.

Challenge: Secure External Access Without User Accounts

External reviewers needed scoped access to a single workflow step without being onboarded as platform users or exposing internal data.

✓Solution: Generated a UUID token per step instance via crypto.randomUUID(), stored against the step and email in DB, and served a public route protected only by token middleware. The workflow engine treats external step completion identically to internal — keeping advancement logic decoupled from user type.

Challenge: Visual Workflow Builder — Schema Design, Canvas State, and Persistence

Needed a schema flexible enough to represent any review pipeline without hardcoding process types, and a UI that let admins define pipelines visually. React Flow's internal node/edge format didn't map directly to the backend execution schema, and the canvas needed custom node types per process category with invalid connection prevention.

✓Solution: Modeled each workflow step as a node with accept/reject route arrays pointing to next step IDs. Built custom React Flow node components per process type with their own handles and configuration modals. Added connection validation callbacks to block invalid edges at draw time. On save, a transform derives the execution schema from the canvas — iterating nodes and reading edge colours (green = accept, red = reject) to build routes. Both representations are persisted: raw React Flow nodes/edges in stepsInfo for direct canvas restoration on load, and the derived workflowSteps array for the workflow engine. This avoids a reverse transform entirely.

Tech Stack

Frontend

ReactTypeScriptBootstrapReduxReact QueryReact FlowReact Beautiful DnD

Backend

Express.jsMongoDBMongooseRabbitMQNodemailerMinIOCron Job

Tools

PostmanSwaggerGit

Impact Metrics

N-stage

Configurable Pipelines

Async

Queue-driven PDF Processing

Versioned

Conflict-safe Saves

Token-gated

External Review Access

My Role

Title

Software Engineer

Duration

Dec 2025 – Present

Key Responsibilities

Visual workflow builder — custom node types, edge routing, connection validation, graph serialization with React Flow
RabbitMQ producer for async PDF generation offloading; workflow stage transitions via directed-graph traversal in Express
Issue Collation module — TypeScript multi-step wizard, JSON-driven dynamic forms, drag-and-drop article grouping, optimistic locking, 9-state issue status machine
Supporting File Validation pipeline — synchronous file server integration, error routing, revalidation UI with file upload
External reviewer system — UUID token generation, Nodemailer email dispatch, public token-auth routes, MinIO file storage, TAT-based reminders via scheduled jobs

Up Next

MES Production Suite

End-to-end Manufacturing Execution System for Amway India covering machine operations, calibration, and quality workflows.

Next Case Study