The single workspace where a federal program lives — WBS, schedule, requirements, risk, and fully-burdened pricing — deployed inside your perimeter.
Interface portraits. Generic data shown — real deployments run on your programs, your WBS, your schedule, your risks.
Illustrative interface portraits · All program names, customers, contract numbers, owner names, and dollar figures are fictional.
The WBS is in one workbook. The IMS is in another. Requirements are in a third, and the trace matrix that's supposed to connect them was last updated before the redirect. Risks live on a slide. Pricing is on a tab in a workbook a former analyst built, and nobody else fully understands the indirect-rate stack.
Each artifact carries its own ground truth. None of them roll up. A program review starts with a half-day reconciling numbers that disagree, and the answer the PM gives at the gate is the most-recent of seven versions, not necessarily the right one.
The cost is real. Re-keyed data, mis-priced bids, requirements that drift from the schedule, risks that don't make it into the brief, color-team comments that vanish into a folder, BOEs that auditors can't trace. Programs miss windows not because the work isn't getting done — because the system holding the work is held together with email.
The bearing: a single workspace, isolated per program, where every artifact lives in one place, every number rolls up, and the pricing volume comes out the back end already burdened and DCMA-traceable.
Four-level WBS with period of performance, complexity tier, critical-path flagging, predecessor logic, and security-domain tagging. Integrated Master Schedule with tasks, milestones, dependencies, and status. WBS and IMS share the same backbone, so a schedule edit and a work-package edit can't disagree.
Requirements register modeled on the SRD — track, status, verification method, compliance reference, priority, and traceability back to the WBS. Five-by-five risk register with score, mitigation, contingency, gate, and program-track alignment. Crosswalk against MIL-HDBK-516C, MIL-STD-810H, Cyber RMF, TEMP, and software standards.
Direct labor cost builder with per-instance rate tables — sixteen standard labor categories, FY-flat or escalation curves, DCAA-aligned. Purchased labor, ODCs, materials, travel, and subcontractor quotes. Indirect rate stacks (fringe, overhead, G&A, fee) configurable per company instance. Executive pricing summary with waterfall and burdened-labor breakdown.
Multi-program by design. One deployment hosts every program the organization runs, each with isolated data and per-company workspaces inside it. A joint venture between two primes gets a single program with two instance workspaces — each company sees their own labor and cost, the PM/Admin sees both. Cost surfaces are hidden from non-admin instances by a separate gate.
Mission-control dashboard rolls up airworthiness progress, cyber-authorization progress, critical risks, pending docs, approved requirements, and active tasks at a glance. Schedule-health view with on-track / at-risk / delayed buckets and upcoming milestones. Charts page for direct-labor distribution and cost-by-resource roll-up. The pricing volume comes out the back end already structured for the proposal.
The platform is private. No program data leaves your infrastructure. The application stack runs inside your perimeter on Docker. Authentication is PIN-based out of the box and integrates with corporate SSO when required. Backups land in object storage you control.
Two levels of isolation. A program is the top-level tenant — every WBS row, task, risk, requirement, and cost entry is scoped to one. Inside a program, instances represent company workspaces (prime, sub, PM/Admin). Foreign keys, application middleware, and admin controls enforce the boundary at every layer. Onboarding a new program is a single form plus an Excel upload.
PostgreSQL 16, schema versioned in code, idempotent auto-seed on first boot. Twenty-one scoped tables tie every artifact back to its program. Excel import per program replaces only that program's data. Nightly pg_dump to object storage (S3, R2, MinIO, or on-prem) with fourteen-day rotation. Restore is a documented one-liner.
Node 24 + Express, bundled to a single binary with esbuild. Drizzle ORM. Multer for spreadsheet upload. Pino structured logging. Sub-1 GB of RAM in steady state. The whole stack — API, database, and outbound tunnel — ships as a three-service Docker Compose file. Runs on a Synology NAS, a corporate VM, AWS GovCloud, or an air-gapped container host with one configuration change.
React + Vite frontend served as static assets behind any CDN or reverse proxy. Mission Control landing page lists every program in the organization. Per-program workspace exposes the WBS, IMS, SRD, risk register, documents, contacts, cost builder, materials, ODC, travel, subcontractors, pricing summary, and executive report. Cost surfaces gated behind a separate admin PIN by default.
HTTPS-only. Defaults to an outbound-only tunnel so the API never exposes an inbound port. CORS-locked to the application origin. Push-to-deploy CI loop for organizations that want it, scheduled pull-and-rebuild on the host for those that don't. Architecture document, restore runbook, and design-system reference ship with the platform so your operations team can run and extend it without us.
Audit how programs are run today — which artifacts exist, which are authoritative, how indirect rates are structured, what auditors look at. Confirm hosting target (corporate VM, on-prem container host, cloud, or NAS). Confirm authentication path. Pick one pilot program small enough to deliver in weeks, real enough to prove the system.
Stand up the Docker stack in your environment. Map your WBS / SRD / risk / IMS templates to the platform's import schema (or adapt the schema to yours). Import the pilot program. Verify rollups against the existing spreadsheets, line for line. Configure indirect rates, labor categories, and FY escalation curves to your DCAA-approved structure.
Per-instance PIN or SSO provisioning. Persona training in 45 to 60-minute sessions — CAM, PM, pricer, executive viewer. Onboard remaining programs. Wire backups to your object storage. Establish the deploy loop your IT organization is comfortable with. Cutover plan timed to your next proposal or program review.
Backup verification drill. Restore-from-backup tabletop. Optional: SSO integration, custom report templates, deeper integration with the system of record (Costpoint, Unanet, SAP). The aim is not a one-time delivery. The aim is an executable backbone the program-management organization runs on for years.
Your team has the engineering capacity to stand it up. We architect, set the eval bar, review the implementation at phase gates, and stay close enough to course-correct before the architecture commits the team to a dead end. Best fit: mature internal IT and PMO teams.
Your team has some capacity but not the right specialization. We run the build in partnership with your engineers — doing integration, data mapping, and the cost-volume math — while your team owns operations and the long-term roadmap. Best fit: federal contractors that need the deliverable operable internally after handoff.
Your team is full-up, or this is too far outside the existing skill set. We deliver the platform, the runbooks, and the persona training, and stay engaged on a defined retainer to keep the system healthy while you decide who owns it long-term.
One conversation, one written summary, no commitment to build. The bearing comes first.
Schedule a call — 30 min