Delivery Hub Spring Roundup — Right-Click Menus, Live Charts, and a Four-Org Sync Chain

A week ago we shipped Delivery Hub 0.184 and a blog post that said drag-to-reschedule was the headline. Since then we've cut nine more library releases, three more package versions, and turned a piece of internal scaffolding into a customer feature twice. This is what changed.

The short version: Delivery Hub now has right-click menus that work the same across three different Salesforce host surfaces, three live charts running on real work-item data, a four-org sync architecture for safely rolling library cuts to production, and a checkout model that turns a public planning page into a purchase order.

1. Right-Click Menus, Three Different Hosts

The Gantt now has a real context menu. Right-click any bar and you get four actions: open the underlying record, edit the item inline, set or change a dependency, and reorder within a bucket. The hover state reads through to the menu — whichever bar your pointer is over when you right-click is the bar the menu acts on, even on a canvas-rendered timeline where the bars aren't in the DOM.

The interesting part is what it took to get the same menu running everywhere we host the Gantt. Three surfaces, three entirely different platform constraints:

• Public webReact component on cloudnimbusllc.com. The library exposes an onTaskContextMenu callback; we render a normal floating menu in the page DOM. Standard stuff.
• LWC inside LEXLightning Web Component embedded in a record page. Locker Service blocks the same callback path the React side uses, so the LWC binds oncontextmenu directly in the template and resolves the target task from the library's exported handle.taskAt(x, y) helper. Same menu, different escape hatch.
• Standalone VFVisualforce + Lightning Out for the chrome-free demo and external-share surface. No Locker constraint, so it uses the same callback the React mount does — one library build, two integration paths.

From a customer's point of view, the menu is just there. From the engineering side, it's the first feature in the library that proves a single API can ride three host surfaces with the right escape hatch picked per surface. Everything we ship from here picks up that pattern for free.

2. Three Live Charts, Built on Your Real Data

The Gantt answers “when does this land?” The charts answer everything else. Three of them are live in the delivery dashboard now, each running on the same work-item data the Gantt does:

• Cumulative Flow Diagram. The classic delivery-team chart that nobody runs because nobody has the data plumbed. We have the data plumbed. Watch the backlog, in-progress, and done bands grow over time and eyeball where work piles up.
• Plan vs. Actual Divergence. For every work item with a planned end date and an actual end date, plot the gap. Outliers are the early warning signal — a single item slipping by three weeks tells you more than a status meeting will.
• Attention Heatmap. Where is your team actually spending hours? Heatmap of logged hours by item and by week. The items with no heat are the items that aren't getting touched — and on most boards, half of them shouldn't be on the board at all.

All three render through a ~50-line direct ECharts wrapper we wrote after the standard React binding silently failed under Next 16 and React 19. (Three deploys to find that one. The wrapper is in the repo if anyone hits the same wall.)

3. A Four-Org Sync Architecture You Can Actually See

When Delivery Hub runs in production at scale, work items don't live in one Salesforce org. They live in four:

Customer Prod → Customer Sandbox → DH Staging → Public Portal

The customer's production org owns the contract data. A sandbox holds the in-flight QA build. A dedicated DH Staging org runs the released Delivery Hub package against real (sanitized) work-item data so every release gets a soak window before it touches a customer. And a public portal mirrors the visible slice for partners and reviewers who don't have a Salesforce seat.

That topology is now visualized live at /sync-topology. Click an org, see what it's holding. Click a sync edge, see which fields it's replicating and which it's deliberately not. We built it to keep four orgs straight in our own heads; it turned out to be the answer to the question every customer asks in the second meeting (“okay, but where does the data live?”).

4. Delivery Hub 0.200 — Invoicing That Doesn't Race

The 0.200 package cut shipped four behaviors customers will notice the first time they use the invoice flow:

• Invoice picker. Generating an invoice now opens a real picker with the eligible line items pre-loaded. No more “guess which work items should be on this invoice and hand-key them.”
• Race-condition fix. Two users hitting Generate at nearly the same moment used to produce two invoices for the same items. Locked.
• Blank-WI guardrail. You can't save a work item with no name. Validation happens at the Apex layer, not just the UI — so the Mothership API and the Gantt drag both honor it.
• Static analysis + tests. New PMD rules and Apex tests landed alongside the fixes. The regression won't come back through CI.

5. The Public Page That Becomes a Salesforce Purchase Order

Most planning tools force a choice: either the conversation happens inside Salesforce (and your prospect needs a license) or it happens outside (and you copy-paste the result back in afterwards). The Proposal Gantt is what happens when you stop making that choice.

The page is a shopping cart. Every line item is a work item the prospect can review on a real Gantt — with dependencies, owners, and hours visible. They check the items they want. Nothing has touched their Salesforce org yet. When they hit check-out, the selected items materialize as WorkItem__c records in the customer's production org with the dependency graph preserved, then sync-chain through to the dh-prod board and back out to the public portal.

The same engine that renders the editable Gantt powers the cart. The same Apex methods that handle a drag-to-reschedule handle the checkout write. From the platform's point of view, a checkout is just a batch commit with a payment reference.

6. Cross-Org Integration Framework

Underneath the checkout flow is a generalized cross-org integration framework that landed this week — the “create a record in another org from a button on this org” pattern with full sync round-trip, no middleware broker required. It's the substrate every cross-org workflow we ship from here sits on, including checkout and the staging-to-prod pipeline.

Why a Roundup This Long Mattered

None of these are individually a headline. But the pattern underneath them is: every cut is a feature on the customer surface that's also a primitive we build the next feature on. The right-click menu is also the way the AI agent triggers actions. The invoice picker is also the way checkout selects items. The sync topology page is also how we explain the data architecture in a sales call. The dh-prod org is also where every cut gets its first real-data soak before a customer sees it.

Free Salesforce-native project management isn't a marketing line; it's the only way you ship at this cadence and let customers actually use it. Per-seat economics would have killed the staging org alone.

Try It

The managed package is free. Install it into any Salesforce org with standard Setup permissions; it's an in-place upgrade from any prior Delivery Hub version. The public planning view and the live charts run with no install at all.