Years on the wishlist, shipped in a weekend — now 300+ uses a day
There was no way to see what was inside a contract from the contract list — not the line items, not the PR / PO / Invoice records tied to it. You opened contracts one by one, or downloaded the PO offline. So I brought both up to the list, coding it myself on infrastructure the team already had: a line-item preview built on the bulk-acceptance pipeline — shipped in a weekend — and a context-aware financials popup that repurposes the contract's own finance page.
My role
PM — spotted the reuse, coded it end to end
Team
Solo, on the team's existing infra
Timeline
One weekend
Usage
300+ requests / day
Weekend
my first production PR at ScopeWorker
300+/day
line-item previews served, seen in Mezmo
89%
feature score
No new backend
reused pipeline + repurposed the finance page
Afterfig.01The line-item preview — every line item across contracts, read from the list, without opening or accepting anything.
The gap
You couldn't see what was inside a contract without leaving the list
The contract list page showed contracts, not their contents. Two kinds of detail lived one click deep, or offline:
Line items — the scope, quantities, and pricing inside a contract. To read them you opened each contract one at a time, or downloaded the PO and read it offline.
Financial records — the POs, PRs, and Invoices tied to a contract lived in its finance section. On the list we showed the PR #, PO #, and Invoice ID — but they were inert text, not links to anything.
Beforefig.00Before — line items lived one click deep, and the PR / PO / Invoice IDs on the list were dead text.
The insight
Everything I needed was already built — for other features
I didn't need new backends. Both times, the data and the view already existed somewhere else in the platform:
The bulk contract acceptance flow already had a pipeline that pulls every line item across every contract in a batch, through one endpoint — exactly what a list-level line-item preview needed.
Each contract already had a finance page rendering its PO / PR / Invoice listings — exactly the view those dead IDs on the list should open.
So the work wasn't building financial infrastructure or a line-item service. It was putting the right, stateful, permission-aware views on top of things the team had already shipped.
Why this was the right size to code myself
The hard parts — assembling line items across contracts, and computing a contract's financial records — were already solved. What remained was the front-facing, stateful layer. Small enough to build in a weekend, real enough to matter.
What I built · 1
A stateful, per-user line-item preview
I built the preview in Angular, using ag-Grid for the line-item table, on top of the existing acceptance endpoint. Two things made it more than a table:
State retention. The preview holds its state — filters, column configuration, expanded rows — as users move around the list, so they don't lose their place each time they come back to it.
Data-access-based views. Line items include pricing, and not every user is allowed to see cost data. The preview renders per user: financial fields are hidden from anyone without financial access, so restricted users see the scope without the numbers.
The judgment call
The moment line items include pricing, "show the line items" becomes "show the right line items to the right person." Gating financial fields by access wasn't a UI nicety — it was the difference between a safe feature and a data leak.
fig.02Same preview, two users — financial fields hidden for anyone without financial access.
What I built · 2
A financials popup that follows you down the list
For the financial records, I repurposed the contract's own finance page — its PO, PR, and Invoice listings — to open as a popup right on the contract list, so the IDs we'd been showing as dead text finally led somewhere.
The part I'm proudest of is how it behaves once open. It doesn't block the page. While the popup is open, you can keep scrolling the contracts behind it and page through the POs, PRs, and Invoices across all of them — without closing and reopening it for each contract. It turns a per-contract detail view into a way to scan financial records across the whole list.
Dead text → a doorway
The PR / PO / Invoice IDs were already on the list — they just didn't do anything. The win wasn't inventing a view; it was making what we already displayed clickable, and then better than the page it came from.
fig.03The financials popup — the contract's finance page, opened over the list and scrollable across contracts without closing.
How it shipped
A weekend, and my first PR into the codebase
The line-item preview was the first pull request I opened at ScopeWorker — a PM shipping into the production codebase, not writing a ticket for someone else to build. Reusing the acceptance pipeline and repurposing the finance page meant there was no new backend to design, review, or maintain; the work was the front-facing views and the access logic around them, which is why real features fit inside a weekend.
Results
Quietly one of the most-used views on the page
300+/day
line-item previews requested, measured in Mezmo
89%
feature score
Weekend
to build, on infra that already existed
300+ requests a day — real production usage on the contract list, confirmed in Mezmo logging, growing as more users discover it
89% feature score, in line with the rest of the platform's most-used views
Zero new backend — the line-item preview runs on the endpoint the bulk-acceptance flow already maintained, and the financials popup reuses the contract's existing finance page
