Try it: install it on your Jira Cloud site. Code: github.com/RohanGlitched/redline.

In short: a drawing revision often changes more than its change order says. Redline compares the two revisions attached to a Jira change order, marks every change it finds, and checks each one against the numbered change notes. Once Redline's validator is on the release transition, Jira will not release the change order until every change is in a note, every value matches its note, and a person has signed it off. On 27 real open-hardware revisions, Redline found 89 changes to parts, connections, values or notes. The commit messages clearly describe 8 and clearly miss 44; the other 37 sit under messages too vague to tell.

Redline compares rev C with rev D inside Jira, clouds each change, then reads the pen marks from a photo of the print

Words used here: a cloud is the bubble a drafter draws round a change; a zone is the grid square named on the drawing border, such as D2.

Inspiration

In October 2024 an engineer committed a new revision of SparkFun's open-hardware GNSSDO schematic with the message "Add mounting holes for SiT5811 / Rakon oscillator". The mounting holes are there. So is a jumper that replaces the 0 Ω link on the 10 MHz output ("Open jumper U to isolate 10MHz"), two clamp diodes at the 10 MHz input, a 50 Ω termination and three new test points. None of that is in the message; Redline, run on the two real revisions, clouds all of it (in the gallery). The message names no drawing zone, so Redline does not tie it to the hole cloud on its own: a reviewer declares the holes against it, and the five other changes stay open until someone writes them up. Nothing went wrong: it is a working commit in an open design. But it is exactly how a drawing outruns its change notes.

In a company the change notes are an engineering change order: "bore Ø25 becomes Ø25.5". The drawing that comes back often changes more: a hole moves, a datum note disappears, a value is typed as 25.6. A checker compares two prints by eye and signs, and the part is made from the drawing, not from the change order. Teams that run change orders in Jira attach the drawings to the work item, but Jira has never looked at them. A slip found on the shop floor means scrapped parts and a new revision. In May 2024 an engineer asked on Atlassian's Community how to tie Jira change orders to drawings in SolidWorks PDM or Autodesk Vault, noting that "lots of teams in manufacturing are using Jira, yet no out of the box integration".

What it does

Find. Redline compares the last reviewed revision with the newest, inside the work item, and clouds every change with its drawing zone. A feature that only moved says how far it moved on the sheet ("Moved 3 mm on the sheet, right and down"); that is paper distance, not part geometry, so the note still has to state the new dimension. Where the PDF keeps its text, Redline also catches one-character edits the pixels can miss (25.5 to 25.6, Rev C to Rev D), and it checks that the title block names the new revision. Plot stamps and labels that only moved are grouped as housekeeping to sign together, never hidden.

Match. Each change is matched to a numbered change note, and its value is checked both ways: note 1 says Ø25.5, the drawing says Ø25.6, so release waits until someone confirms the drawing or sends it back. A change no note describes gets a drafted note ("Zone B4: line work removed") that you rewrite ("Zone B4: datum feature removed") and add to the change order with one click; it says it was written in Redline, and by whom.

Answer the shop floor. A phone photo of a marked-up print is flattened onto the new revision, pen red is separated from printed red, and each pen mark must be raised as a work item, covered by a change, or dismissed.

Hold. A workflow validator refuses the release until every change is declared and signed off against the note's words, every value matches, every pen mark is answered, every sheet is compared and the review covers the newest revision. It reads the review from app storage and fails closed. Open items carry into the next revision's review. A dashboard gadget, JQL redlineGate = "blocked" and a Rovo agent show what is held, why and since when.

Each sign-off records the signer's Jira name and the note's words at that moment. A project administrator can limit sign-off to a Jira group and keep the person who attached a revision from signing off its changes; the server checks both on every save. Who can release is set by Jira's transition permissions. Everything runs in the browser and in Forge. Drawings never leave Atlassian, and the comparison calls no AI service.

Evidence on real drawings

We ran Redline on drawings nobody prepared for it. Open-hardware projects have no change orders, so each commit message stands in for the change notes: a commit message is not a change order, but it is the same act, an engineer describing their own drawing change.

  • 27 revision pairs (118 sheets) of seven SparkFun schematics, December 2023 to November 2025.
  • Redline drew 321 clouds and we classified every one, cloud by cloud: 89 are changes to parts, connections, values or notes; the commit messages clearly describe 8, 44 are clearly missing, and 37 sit under messages too vague to tell. In 9 of the 21 revision pairs with such changes, the message clearly misses at least one.
  • Most of the rest were layout moves, library refreshes, plot stamps and redrawn frames. That is why Redline now measures moves and groups housekeeping.
  • 20 differences were set aside as re-plot shifts; we published all 20 side by side, and each reads the same before and after.
  • Limits: these are electronics schematics, not mechanical drawings, and most had no text layer, so the value check had little to read.
  • A correction: our first version of this table mixed up two drawings that share a file name. Running Redline live on the real GNSSDO revisions showed the mismatch; the table, figures and numbers here are the corrected ones, and the repository says what changed.

The table and scripts are in docs/real-world-run.md. Drawings shown from this run are © SparkFun Electronics, CC BY-SA 4.0; our figures are cropped and annotated by us and shared under the same licence.

On a benchmark we built from public-domain NIST test drawings with edits we planted: 431 of 432 visible edits found on digital revisions with no false clouds on unchanged sheets; 92.1% on simulated rescans with about 1 false cloud a sheet; 160 of 160 pen marks on 60 simulated phone photos. The sample in the app is a NIST model-based definition view; Redline compares any PDF drawing sheet, digital or scanned, the same way, and the benchmark measured both.

How we built it

How Redline checks and holds a change order

  • The comparison runs in the reviewer's browser, inside Jira, so drawings never leave Atlassian. Forge's content security policy allows no WebAssembly, so the engine is plain JavaScript. pdf.js renders each revision and reads its text. The engine lines the revisions up (image moments, then pyramid Lucas-Kanade), diffs the line work with a small positional tolerance, sets aside re-plot shifts, matches removed ink to added ink to measure moves, and groups changes into clouds with ASME-style zones.
  • Paper markups: the photo is flattened onto the new revision (a homography, then refined), and pen red is separated from red printed on the drawing.
  • The server checks every save against the stored review: signer names come from Jira, a save must name the revision pair the gate expects, it can never drop a change an earlier comparison found, and every save is audited.
  • One verdict everywhere: shared/gate.mjs runs in the browser and in every Forge function (validator, gadget, Rovo). 78 tests cover the gate, change notes, housekeeping, re-reads, pen markups across revisions, the title block, text comparison and which change a pen mark points at, plus the save, release-gate, add-note and sign-off-rule resolvers against stand-ins for Jira and app storage.

Technical requirement: Forge modules and Atlassian products

Jira: jira:issuePanel (the panel; the light table opens from it in a Forge modal), jira:workflowValidator (the release gate), jira:dashboardGadget, jira:entityProperty (JQL redlineGate), and two trigger modules (issue updated: keeps the JQL index current; issue deleted: removes Redline's records). Rovo: rovo:agent with two action modules. Storage: Forge KVS. Runs on Atlassian: no egress, no remote backend.

Challenges

  • Forge payload limits: drawings arrive in 3 MB slices, photos are re-encoded under the bridge limit, and sheets are drawn at no more than 16 megapixels so E-size sheets render on any device.
  • Making the gate trustworthy when the comparison runs in a browser: the server owns the signer names, the revision pair and the list of changes, and audits every save. The first comparison, and a re-read after a Redline upgrade, come from the reviewer's browser; both are audited.
  • Real PDFs: re-exports nudge line work and restamp dates. Setting that aside without hiding a real edit meant checking every piece of ink on its own, and keeping what was set aside visible.

How it differs from drawing compare tools

Bluebeam, AutoCAD DWG Compare and SolidWorks Compare show where two revisions differ. Redline starts there and asks the change-order question: which numbered note describes each difference, does its value agree with the note both ways, who signed it off against the note's words, and what did the shop floor mark on the print. Then it refuses the Jira release until every line is answered, inside the work item where the change order already lives. Teams with a PLM system (Windchill, Arena, Teamcenter) run change orders there; Redline is for the hardware teams and contract manufacturers who run them in Jira.

What we learned

Engineers already write zones into change notes, and drawings already carry their values as text. Using both turns "something changed here" into "this is the change note 1 describes, and its value is wrong". Real drawings taught us the rest: re-exported PDFs nudge line work and stamp new dates, and a reviewer needs to tell a moved hole from an edit at a glance.

What's next

Several drawings on one change order (today Redline compares one drawing per change order); read the drawing's revision history table; tolerance-aware value checks; trials with scanned prints from a shop floor.

Bonus: Rovo agents

The Drawing change checker agent (rovo:agent) answers questions about change orders reviewed in Redline through two actions. get-drawing-review returns one change order's changes, their declarations, value checks, pen markups, sign-offs and the same release verdict the validator gives. find-blocked-change-orders lists the change orders Redline is holding, found in app storage rather than through an editable property. Try: "Which change orders are blocked by undeclared drawing changes?" or "What changed on ENG-5, and is it declared?"

Built With

Share this project:

Updates

Submission history