What happens to a deal you put into Underwrite.

Four features send data to the processing service's API, each only when you click it, each through Underwrite's server, and each returns material a human reviews: the parser, the comp reader, the deal review and the memo's executive summary. Two of them change no number: the deal review and the memo's executive summary are written about figures the engine has already produced, and what they return is prose, checked against the engine before it is shown and refused if it disagrees.

The parser is different. It returns field values, those values are written into the inputs panel, and the engine recomputes from them: exactly what happens when you type a value yourself. What it cannot do is produce a result. It fills inputs; it never returns an IRR, a multiple, a verdict or a grade, and no figure it returns is used as an output. On a hotel deal it reports the ADR, occupancy and RevPAR the document states, and the server, not the model, turns them into a monthly revenue per key in code. That row is labeled as computed by the server, it lands in an input you can see and change, and /methodology/hotel states the conversion. The model has one commercial line: office or other space a document describes beside the retail is named beside the result and its income left out, not folded into the retail line.

The comp reader is the parser reading a comp file you choose on the desk: a rent or sale comp report you exported from a service you use. It goes the way a deal document goes, and comes back as rows, each with the line it came from. Code computes their counts, ranges and medians beside your assumptions, and no comp changes an input unless you click to use its median. Underwrite has no comp data of its own and does not verify yours.

The calls run under the processing service's commercial API terms, which do not use the input for training. Underwrite trains nothing.

On the desk, each figure is labeled: extracted values read Extracted from source with the sentence behind them where there is one, calculated results read Calculated by model, and anything you override reads User assumption. A figure the server computed from values your document states, such as a vacancy from a stated occupancy, reads Computed by the server, with its formula. On a deal of your own, an input no document and no edit set, which still holds the worked example's value, reads Sample assumption. Judgment calls the engine cannot make are routed to analyst review and say so.

What is read

Source quotes

A quote appears only when the server found the sentence in your pasted or spreadsheet text and it states the value. It stays at that field for the session that parsed it. Every other value is flagged with the reason, or says how the server computed it. The server passes a PDF to the model without reading its text, so every PDF row is flagged and its sentence is the model’s account of the document, not a checked quote. Quotes are not carried into a saved deal or a share link, and tenant rows have none.

Confidential Mode

It turns off the parser, comp reading, the AI review, the memo's AI summary, share links and memo links, and the public rent lookup where it is set up. Everything else keeps computing in your browser.

Source trail

Source trail walks the IRR back through the cash flows and revenue assumptions to the seller’s sentence on rent. It shows a calculation and its inputs. It does not cite a source for every figure. The desk uses the same tool.

The figures below are the capability report of the deployment serving this page, the same report the upload panel reads.

The mechanics behind those numbers: a PDF at or under the direct ceiling travels inside your parse request. A larger PDF is staged, from your browser, into private blob storage under a server-issued token scoped to PDFs, to one folder, to the size ceiling, and to a few minutes. The store is private: the document never sits at a public address, the parser service cannot fetch it by URL, and only Underwrite's server token can read it back. The server verifies the staged reference is its own, refuses foreign hosts and malformed paths, and deletes the blob the moment the parse settles, on success and on every failure path. Excel workbooks never travel as binary: they are opened in your browser and only their cell text, normalized and capped in size, is sent, with formulas and macros never executed.

Underwrite's operator log records sizes, timings and errors. When the server withholds the parser's note, or refuses an AI review or summary, the log line quotes the figure or word that caused it, and on a PDF that figure can come from your document. Rate limiting is per IP and applied on the server, with the ceiling above read from the limiter's own constant. The count is held in memory per server instance, so it is a service protection, not a hard guarantee: several instances, or a restart, can let more through.

An AI-extracted value arrives either with a source sentence or with a flag that says why it has none: the sentence was not found in your document, it does not state the value, it came from a PDF the server cannot read, the row is a tenant row this parser does not quote, or no sentence came back at all. A value the server computed from figures the document states is not flagged; it says it was computed, and from what. For pasted text and workbooks the server holds your source, so it asks two questions of every quote the model returns: is this sentence literally in the source, and does it state the value being claimed. A quote that fails either is not provenance. It is still shown, beside the hand-verify flag, and labeled as reported rather than attested. The server passes a PDF to the model without reading its text, so only the second question can be asked of a PDF quote: the server checks that the sentence the model reports states the value beside it, and cannot check that the sentence is in your document. Every row read from a PDF carries the hand-verify flag, and the sentence it reports is the model's account of the document rather than a verified quotation from it. Tenant rows extracted from a rent roll carry no quote at all: they arrive as an audit row with the term the document stated, and the per-tenant sentence is not tracked yet.

The desk states each input's standing in two places. In the parser's list of what it extracted, a value shows its quote, or an amber flag to verify it by hand when no quote survived; every tenant row from a rent roll is in that list with the amber flag. In the inputs panel, each parsed field carries a gold dot whose tip shows the sentence or says no sentence came back. Tenant cards carry no dot, so a tenant row's standing is shown only in the parser's list, and hand-entered fields claim no source at all. The moment you edit an extracted field, the dot gives way to a User assumption ring: the quote attests what the source said, not what you chose, so a value that departs from its evidence is visibly yours.

Source quotes are state in the tab that parsed the document. They are not written into a saved deal, they are not encoded into a share link or a memo link, and loading a deal from the library clears them. A colleague who opens your link gets the deal's values and no evidence behind them, and so do you when you reopen your own saved deal: the desk shows those fields with no provenance rather than with provenance it cannot stand behind. The workbook and the printed memo do not carry the quotes either. Nothing Underwrite produces is a substitute for keeping the source document beside the deal.

The change record works the same way: the desk keeps the deal as it arrived (from a parse, a link, the library, or the defaults) and diffs the live model against it, so every edited assumption is listed with its loaded value, its current value, and the measured impact of that one edit, with one-click restore. This record is derived from the live session, not stored: Underwrite keeps no server-side history of your edits, and a saved deal is a snapshot, not a log. There is no edit history across sessions: a deal saved in this browser, or to your account with Underwrite Core, holds the deal as it was saved and nothing of how it got there.

Macro series (Treasury curve, SOFR, CPI, inflation expectations) come from FRED, fetched by Underwrite's server; provider keys never reach your browser, and the requests carry no deal data. Every figure keeps three facts separate: the observation date it describes, the cadence it can possibly move at, and the moment Underwrite last called the provider. A monthly CPI print is labeled as the month it describes and never dressed up as an intraday read. When the provider is unreachable or unconfigured, the product serves labeled fallback figures and never presents them as a market observation.

Beyond the FRED series, many Phase 3 market overlays run on seeded calibrations until direct data licenses exist; each is tagged live, hybrid, seeded, or derived in the module inventory, and the memo's module notes say which is which.

A deal saved to this browser's library exists in its local storage, on your machine. Delete any deal from the library, or clear the site's browser data to remove everything at once. Without sign-in there is no copy on Underwrite's server to request, and no one at Underwrite can pull up a deal from a database. With Underwrite Core, saving a deal to your account sends it to Underwrite's server, which keeps it privately under the account, in a folder with a random name; you can download or delete it from the account at any time, and a deal with Confidential Mode on is never saved there. Access is whoever can use your browser profile or your account, plus anyone you hand a share link, plus whatever the hosting platform's access log retains of the request lines of the memo and share links that were opened. Those request lines carry the encoded deal, the founder can read that log, and this product neither controls its retention nor promises to delete it. Confidential Mode turns both link flows off, which is the way to keep a deal out of it.

The transient exceptions are the AI requests themselves: for the seconds a parse, review, or summary is in flight, the material you sent exists in the request path (and for a staged PDF, in private blob storage that is deleted when the parse settles). Those requests are handled by the processing service under its commercial API terms, which do not use the input for training.

Two other records persist. Usage events carry an event name and three random ids this browser made for itself: one for the browser, one for the tab's session, and one for the deal being worked on, which a share link also carries so a forwarded copy is not counted as somebody else's second deal. None of the three is derived from your property, your document, your numbers, or a hash of any of them. Clearing site data severs them from anything recorded before. An event can also carry a few fixed-choice facts about the step: the deal's property type, which input was edited and whether the edit moved the verdict, how many fields a parse returned and how many it quoted, and whether the source was text, a PDF or a spreadsheet. Never a value, a name, a quote or a file.

Deleting those events is a pass the founder runs, not a background timer. The window is 90 days: a day older than that is deleted when the pass runs, and each pass writes a receipt saying what it deleted and when. Until a pass has run, the events are still there. If the store is unavailable the event is not recorded at all, and the diagnostic line left behind names the event and nothing else: no ids, in a platform log this product does not control and does not promise to delete.

A subscription record (customer id, email, plan, status) is a business record, kept for as long as the business needs it and deliberately not covered by the usage-event window above: email ali@getunderwrite.com to have it removed.