A development deal is one number that changes for three years.
Most teams track that number in three places. The underwriting model that won approval sits in a spreadsheet nobody has opened since closing. Construction lives in a second one, where the actuals accumulate. Investor reporting is a third, rebuilt by hand every quarter. All three describe the same deal, and they disagree — quietly, until someone reconciles them under deadline. ProForma Suite is one model with three workspaces on top of it, so the disagreement can't start.
Construction actuals re-solve the underwriting
When a subcontractor's invoice lands against a budget line, the app doesn't just record it. It forecasts what that line will cost at completion, adds up the same forecast across every hard-cost line, and runs the result back through the exact returns engine that produced the original underwriting. Within the same render you can see what the spend did to LP IRR.
The forecast is earned-value arithmetic, not a guess: a line's cost-at-completion is its budget divided by its cost performance index — what you've actually spent versus the value of the work genuinely in place. Approved change orders raise the forecast on their own, before any spend is recorded against the new scope. The projected overrun is then modeled as additional equity, split pro-rata between LP and GP, because that is what actually moves the LP's return.
One deliberate constraint: this never overwrites your underwriting. The variance runs on a throwaway clone and comes back as a labeled forecast overlay next to the base case. The model that went to committee stays exactly as it was approved — you compare against it rather than losing it. When there isn't enough construction data to project a trend, the app says so instead of inventing one.
The hard-cost budget is an allocation of the same Sources & Uses figure the model already carries — not a re-keyed copy of it. The two reconcile by construction.
Actuals and approved change orders forecast cost-at-completion, which re-runs the returns as a variance scenario. Trending 2% over the underwritten hard costs flags red; the band just under it flags amber, while there is still time to act.
LP distributions and capital accounts are read from the waterfall and the ledger, never typed into a report. What the investor sees is what the model computed.
Accounting that can't drift
Investor capital is accounted in whole cents as integers. Floating-point dollars never touch the math, because 0.1 + 0.2 is not 0.3 and a rounding error in a capital account is a phone call with an LP. When a distribution is split across investors, one primitive does it — largest-remainder allocation — so the parts sum to exactly the whole and the leftover cent lands somewhere predictable rather than nowhere.
The event log is append-only. There is no edit and no delete: a correction is a reversing entry plus a corrected one, so the history of what you told your investors survives the correction. Capital accounts are never stored, only derived — every figure on the Investors page recomputes from the event log, which means it is reproducible rather than remembered.
Holding it together is the tie-out invariant. The sum of every investor's capital account must equal the project's equity position computed independently, over the same events, by deliberately different code. Two paths, one answer. If an allocation bug ever made them disagree, the ledger refuses the write and the page tells you — rather than letting a half-cent hide in a footnote for six quarters.
Enforced on the server, not in the interface
Your concrete sub gets a portal with their schedule, their RFIs, and the documents shared with them. Not the deal's returns, not the equity structure, and not the electrician's contract value. An LP gets their own capital account and distribution history — their position only, never the other investors'.
That boundary is enforced where it can't be inspected around. Portal users hold no read access to the underlying project at all: a direct API call with their credentials returns nothing. Everything they see is assembled server-side, per request, from a grant that is re-checked every single time — so revoking access cuts the next request, not the next login. Restricted collaborators are served a redacted document; the hidden sections aren't styled out of view, they are never sent.
Getting in is a single click. Subs and investors authenticate with a one-time emailed link — no password to choose, no account to set up, no profile to complete — and stay signed in afterward. It's the least ceremony we could put between a busy subcontractor and their own schedule.
Hurdles solved, not approximated
Return of capital, preferred return accrued on unreturned capital over actual elapsed time, an optional GP catch-up, then promote tiers. Each tier pays at its split until the LP's achieved IRR reaches that tier's ceiling — and that IRR is solved from the LP's real dated cash flows, not approximated from a ratio. The structure is yours to configure; the arithmetic isn't negotiable. Every dollar distributed lands with the LP or the GP, and the tests assert it.
The same engine drives the projection and the actual distribution. A distribution you run is the modeled waterfall applied to real cash, posted to the ledger as events — so the promote you collect and the promote you underwrote are computed by one piece of code, and any gap between them is a fact about the deal rather than an artifact of two spreadsheets.
Dense, fast, and honest. The interface looks like the terminals our users already trust because the work deserves that seriousness — no dashboards that hide the math, no charts that flatter the deal. Every number is traceable to the input that produced it, and validation runs continuously: debt service coverage, debt yield, loan-to-cost, sources versus uses, flagged in plain language the moment they break.
The rule underneath all of it: the software never invents a number. A projection is labeled a projection. Missing data produces an empty state, not a plausible zero. If the app doesn't know, it says so — which is the only way a model earns the right to be believed at the one meeting where it matters.
Early access. ProForma Suite is built with working developers rather than for a persona — including against a live construction deal and a real contractor's cost estimate, which is why the construction import handles the messy spreadsheet you actually have instead of the tidy one a demo would use.
We don't have a wall of customer logos yet, so we aren't going to show you one. No invented testimonials, no borrowed credibility, no "trusted by" counter. When there are real names and real quotes, they'll appear here — with permission, and attached to people who actually ran a deal on it.