The Production Module in RevukCRM: How to Run an Order from Deal to Warehouse

Most CRMs end where manufacturing begins. The sales rep closes the deal — and the customer "vanishes" into the workshop's spreadsheets, where nobody sees the order status, the material stock, or why a batch has been stuck for the third day. RevukCRM closes that gap. Production orders live in the same workspace as deals, contacts, inventory, and finance — and move through a funnel with its own rules, templates with options, and a dedicated page for the operator on the shop floor.

This is the pillar article for the production module: a full walkthrough of how the work is structured and what steps the manager, operator, and lead take.

What you get in one workspace

• A production funnel — statuses and when → do rules that move orders and deals between themselves automatically
• Templates with stages, material norms, parallel branches, options, and "What the shop will do" — an instant route and time calculation
• A production board with order cards, filters, and a Board/List toggle
• An order card where quantity flows through stages, and unfinished work is recorded with a reason rather than silently
• A mobile-first "My Stages" page for the shop-floor operator
• A subcontractor directory with a dedicated portal and a satellite acceptance stage
• Defect tracking with reasons, a "rework / accept as is / write off" decision, and photos
• Reservation, write-off, and auto-receiving of finished goods to inventory
• Automatic costing — with a snapshot of rates and material prices
• Seven thematic reports — from operator workload to defect breakdown

Why manufacturing and sales must live in one workspace

The classic scenario: sales runs in one system, production in another, inventory in a third, finance in a fourth. The rep sees the deal but doesn't see that the batch is stuck at "Grinding & Packaging." The operator sees the task but doesn't see that the customer has already called twice and wants to cancel half the volume. The bookkeeper sees the invoice but doesn't see how much material was actually used.

In RevukCRM these layers converge in one place. A production order is tied to a deal, the deal to a contact, the contact to a chat and call history. When a rep opens the deal card, they see a "Production" block with the current status. When the operator hits "Close stage" on the last step, the deal status flips to "Ready for delivery" — no separate notifications, no copy-pasting into Excel.

That means fewer people in the chain, less "call me back to check," and none of those moments when you promise the customer something that's been sitting half-done for three days.

Where work starts: the production template

Before you launch the first order, you build a production template — the sequence of stages and material norms per unit. One process — one template, and you attach as many products to it as you like. If you have three types of roasted beans made the same way, that's one template, not three copies that will drift apart in six months.

Templates live under Production → Templates.

Tabs at the top — All · Active · Draft · Archived: while a template is not ready, it stays in drafts and isn't offered for new orders; archived templates disappear from selection but already-launched batches finish under them. Each row instantly shows how many products the template serves, how many stages it has, and how many options.

Three editor tabs: Stages · Products · Options

The template editor is a two-column screen: the stage list on the left (drag-and-drop reordering), the inspector for the selected stage on the right.

The example above is Arabica Premium 250g coffee, three stages: bean roasting, degassing, grinding and packaging.

What you set on each stage

For every stage:

• Name, planned duration, and instruction — a short title plus the detailed text the operator will see on their screen
• When material comes off the shelf — on stage close (when actual consumption is known only after the work) or up-front on the full input (fabric for cutting is issued with the task)
• What must be done first — dependencies on other stages; while none are set, the template runs as a chain, but as soon as you set one, stages without dependencies become the starts of parallel branches and run in parallel
• Who performs — internal, subcontractor only, or "decide at launch"; the default person or role is set separately
• Acceptance after subcontractor — flip the toggle, and a dedicated QA task with its own owner and time is added to the template automatically
• Materials for the stage — norms per unit, either for a specific product or shared across all products on the template

What the shop will do — the route in half a second

The "What the shop will do" button at the top of the template shows the real route for an order with the chosen options: how many stages will run, how long each takes, and what the total is. The rep sees the same screen later when creating an order.

Options — stage sets under a condition, not a separate template

In older CRMs "Coffee with gift wrap" is a separate template, and in six months you have 32 templates for five upsells. In RevukCRM it's an option: a stage set added to the main route if the customer bought the relevant upsell product or the operator flipped a manual toggle.

Options sit inside a single ordered stage list alongside the base ones — you can put "prepare stencil" second and "apply lettering" sixth. This solves a real problem: where you used to have 32 templates, you now have one.

Why you can edit a template without fear

Every order takes a template snapshot when it's created. If the technologist adds a new stage tomorrow or changes a norm — it only affects new orders. Batches already in progress keep running under the rules they started with.

Production funnel: statuses and rules

In old CRMs, "when a production order gets created" lived in the template's jsonb settings and quietly stopped working when a status was removed on the sales side. In RevukCRM this is run by a dedicated production funnel — statuses plus when → do rules.

Three statuses are system-defined and can't be deleted: New — the entry point for new orders; Done — the exit for finished ones; Cancelled — the exit for those that won't be done. Between them you configure your own. The example above shows Prep and In progress. The order is set by drag; the status color matches the dot on the board card.

The when → do rule

A rule describes an event on the production or sales side and the action to take in response. The modal has just two choices — when and what.

Typical rules a workspace ships with:

• Deal entered status Paid → create production order
• Order entered status New → send to the shop
• All items produced → move the order to Done and the deal to Ready for delivery
• Stage Packaging started → move the order to status Packaging

These are actual rules, not hardcoded logic. If a status is deleted on the sales side, the rule is flagged as "broken" — it doesn't silently stop working. Every status movement is logged: who moved it, and whether it was a human or a rule firing.

Production board: one window for the shop lead

All active orders come together on the production board. Columns are your funnel statuses, order cards drag between them, and there's a switch to the list view.

What the card shows

• Order number and source deal
• Urgent / High priority badges and a shortage badge if inventory is short
• A red Overdue highlight if the due date passed
• The first few items — "and N more" if there are many
• "Items done: X of N" counter and a stage progress bar

Filters

Top of the screen: search by number/deal/note, toggles for Overdue and Unfinished, and a Board / List switch. In list mode cards become rows, checkboxes appear, and a Merge function activates — combine several small orders into one, useful when reconfiguring the machine is cheaper once than for each order separately.

One order, many items

One order — as many items inside as you need. This is the key difference from "classic" logic: "two Napoleons, two Cherries, and one Cherry with lettering" is one order with three items, not three separate tasks. Each item is its own production card with its own route and its own quantity.

Creating an order is one New order button in the board header. No modal with required fields: the order is created empty, and items are added right on the card.

Adding an item — two steps

The + Add item button opens a catalog search and lets you set quantity and options for the selected product. Each product variant becomes a separate item — "5 black hoodies + 3 grey ones" = two cards with different fabric colors, not one card with two checklists.

Split and merge — when reality doesn't match the plan

There's a Split button on the card: the customer changed their mind, and half the order needs to move to next week or split off into a rush batch. Instead of copying the order by hand, you pick items and move them — the new order carries its origin.

The reverse — Merge — is on the board in list mode. Several small orders combine into one when reconfiguring the equipment is cheaper to do once than for each separately.

Quantity that flows through stages

The key difference of the new production module from "usual" ones — quantity doesn't sit on the item as one number, it flows through the stages. Every stage has its own input (what came from the previous one) and its own actual (what was really produced). Closing a stage short shrinks the batch and recalculates material demand for the following stages.

Two different actions: "Record" and "Close stage"

These aren't the same thing, and it's worth not conflating them.

• Record is a report: "Peter made 5 out of 10 cakes." The stage stays open, quantity accumulates. You can register defects at the same time: "5 good + 1 spoiled."
• Close stage is a decision. After it, quantity is locked; the next stage sees exactly this number. If you close short — a reason is required: Ran out of materials · This is enough · No time · Other. This isn't a defect — the item simply wasn't made, no material was consumed.

That's the difference between "today we made 3 more, tomorrow we'll finish the rest" and "we're making this many on this batch and that's it." Without that difference either the shop lies to the system or the system lies to the shop.

Several operators on one stage

Previously a stage had one owner, and the second baker was formally "doing nothing." Here two bakers take 5 cakes each of 10, each reports their own — the sum is the stage's total, and each half goes into costing at that person's rate.

Actual time — as segments, not "start/close"

The gap between "started at 5:50 PM" and "closed at 9:15 AM" lies about anything you began in the evening and finished in the morning. That's why time is counted in segments: start opens a new segment, pause closes it. On the card and in reports you see not "16 hours 25 minutes" but a real 2 hours 45 minutes of actual work.

"My Stages" — a dedicated screen for the operator

The operator doesn't need access to the lead's board, to financial reports, or to the template editor. They need to know: what can be started right now, what's waiting on something else, and what's already done. That's what the "My Stages" page is for — with two groups of work.

Left — the work queue, split into two groups:

• 🟢 Ready to start — stages the queue reached: the previous one is closed, you can begin
• ⚫ Waiting on previous — dimmed cards with the caption "← waiting: Bean roasting — done 0 of 20"

Right — the detail view of the selected stage: header "Order #N · product", norm and actual time, shop-floor instruction as a blue card, counters in one row — received / done / defect / left (the big "left" number in the primary color). Big "How many did you make just now?" field with −/+ buttons. Defects field and Defect reason selector appear when defects > 0. Buttons Record N pcs ("stage stays open"), Close stage ("pass N along to «Degassing»"), Start / Pause — for the time tracker.

Big buttons — so you can hit them even with a glove on. The page updates in real time: when the lead in another workspace reassigns the stage to someone else, the operator sees it without reloading.

Defects: reasons, decisions, photos

A defect isn't the same as unfinished work. Unfinished — the item wasn't made, no material was used. A defect — the item was made and ruined, the material is consumed. So a defect has both a cause, a decision, and a cost.

A reason list, not free text

Defect reasons are a dedicated list the admin curates: "Operator error," "Bad material," "Equipment failure," "Damaged in transit," "Other." The list seeds in the company's language on first access to the module. The name is snapshotted on each defect record: the admin can rename a reason, and a report from last month stays readable.

Three decisions on a defect

Once a defect is registered, the lead picks one of three:

• Rework — the closed stage reopens, the clock starts again. On reopen the system publishes a "rework_started" event — automations usually hang a customer notice about the delay and a re-consumption of material on it.
• Accept as is — the item goes back into the batch: it's no longer a defect, "defects" shrinks, "done" grows, the chain recalculates. The classic "sell at a discount."
• Write off — the item leaves the batch as a loss. Material is already gone, so it lands in cost.

Defects can only be registered on an open stage. A defect noticed later belongs to the stage where it was spotted — otherwise the numbers of closed work would change retroactively. A photo attaches inside the modal: without a photo, the "was it you or did it come this way" argument is unwinnable.

How defects affect the numbers

• Materials: consumption is based on "good + defect" — the fabric on the ruined piece was used just the same.
• Costing: depends on the setting — either defects load onto the good units (typical for volume production with a small defect share) or come out as a separate "defect loss" line.

Materials and inventory: reserve on "Send to the shop," write-off on the fact

Manufacturing without material tracking isn't manufacturing, it's a lottery. In RevukCRM inventory is integrated from the start: when the order is sent to the shop, the system automatically reserves the norm. If something is short — a yellow "shortage" tag appears on the card and on the board, but launch isn't blocked. Shops often start knowing the fabric will arrive tomorrow; a hard ban would make them route around the system.

Write-off can be configured to the process:

• On stage close — by what was actually produced. Fits when material is taken along the way — thread, paint, boxes.
• On stage start — fabric is issued for cutting with the task, and inventory has to see it immediately. On close, the surplus returns to inventory automatically.

Calls to inventory go through a queue with an idempotency key: if the network fails right when the stage is closed, the operation retries itself. A lost write-off is a discrepancy nobody will find later, so the reserve/write-off mechanism is designed to survive a one-off outage.

Costing: automatic, with a rate snapshot

RevukCRM computes batch cost on its own. Not a "10% markup on materials," but the real one — materials from stock at the actual price, labor at operators' rates, subcontractor pay, and financial defect loss.

Everything — a snapshot at stage close, otherwise a March rate bump would retroactively make February orders more expensive. Stage time is split between operators in proportion to what each produced: whoever did 5 out of 10 gets half the time at their rate.

• Materials — by what was actually written off, at the purchase price at the moment of write-off
• Labor — by actual time and rate (personal or role rate, however configured)
• Subcontractor — by the amount entered when the stage was handed over

Manual recosting is there too — when you raised a rate, fixed a purchase price, or confirmed an inventory movement, snapshots refresh from scratch.

The cost number flows back to the deal card — the rep sees the real profit from the customer, not a top-down estimate.

Finished goods — where and when to receive

Many CRMs used to end at the last stage close — the units only existed as a number on the card, with nothing to sell. In RevukCRM this is closed by a dedicated Finished goods block.

Options:

• Receive produced units automatically — as soon as an item is finished, the units land in inventory. Turn off if you run finished-goods inventory separately
• Finished-goods warehouse — where to receive; company main warehouse by default
• Allocate produced units to the deal — without this, a sale on the same deal will reserve the same units again, and inventory will show a shortage where everything is in place

On the same screen you pick the defect cost policy: "Bury in the price of good units" — defects load onto items that reached the customer (typical for those where defects are a normal part of the process); "Show as a separate loss" — the cost shows what it takes to make it right, and losses are visible as a separate number.

The system receives what was actually produced, not what was ordered: out of a thousand T-shirts you get exactly what came through. Manual receiving is there too — for cases where inventory didn't accept the movement and you need to retry.

Subcontractors and passing stages outside

Not every stage runs in-house. Engraving, laser cutting, dyeing — often go to an outside master. RevukCRM has a dedicated Subcontractors section with a directory and its own handover logic.

When the lead hands a stage to a subcontractor, they capture subcontractor pay (flows into stage cost alongside materials and labor), return promised by (the deadline the system will nudge on), and a brief with files.

Acceptance as a separate stage, not a status

The key difference — on the template you just flip "Require inspection after subcontractor", and a dedicated satellite acceptance stage with its own owner and time is inserted into the route. It's a real task: the check is done by a different person, it takes time, and someone else is accountable for it.

A portal for the subcontractor

A subcontractor can have limited access to their own portal — only their stages and files, without access to the rest of the CRM. Access is granted from the directory: the admin sends an email invitation, the subcontractor sets up an account, and sees what was handed to them.

Seven production reports

A dedicated Reports section brings together seven thematic windows with a single top filter — period, products, operators, subcontractors. The lead switches between reports without resetting the range.

• Orders — volume, statuses, average cycle time; by products and over time
• Workload — hours per person, top performers, average stage duration
• Overdue — orders and stages past due, with the hours of overrun
• Materials — norm vs actual, cost, over-consumption in % per material
• Costing — cost breakdown by product: where you make money and where you barely cover costs
• Defects — reasons and stages, financial impact
• Subcontractors — who received how much, how much was accepted, how much was paid, defect share

Every report exports to XLSX or CSV for the bookkeeper — straight from the top bar.

Who it fits

The module's logic is flexible for many kinds of production. A few real examples of how it's configured.

Apparel manufacturing. One "garment sewing" process — one template for all models of the same cut. Options: "Embroidery," "Gift wrap." Funnel rule: when deal → "Accepted for work" → order is created. Subcontractor for embroidery with mandatory acceptance.

Custom furniture. Each kitchen module or cabinet — a separate order item with its own route. The operator is picked at launch. A tech pause for lacquer to dry. Photo capture is mandatory, and a defect like "part of the blanks came with cracks" is resolved with "Rework."

Pastry and bakery. One "Baking" template for the whole cake line, product variants split into items. Tight deadlines — a funnel rule "overdue → notify the lead." Inventory integration is critical — a yellow "shortage" is instantly visible on the board.

Woodworking and forge. Several items per order, acceptance after a subcontractor as a separate stage, subcontractor pay recorded at handover and included in cost.

Runs and contract manufacturing. Several small orders merge into one batch via the Merge function from the board list.

Coffee roaster — the example the screenshots in this article are built on. Three stages, a 12-hour tech pause, batches of 20–100 bags. The "Gift wrap" option is added with one checkbox at ordering.

What's next

The RevukCRM production module covers the full cycle — from the moment a deal moves into "Accepted for work" to the moment the finished batch is received into inventory. It closes three big problems of classic production companies: the gap between sales and the shop floor, manual material and defect tracking, and the inability to compute real cost.

Upcoming articles in this cluster will go deeper into individual parts — templates with options, the funnel and rules, defect tracking, cost calculation, reports.