---
title: "How to Share an Interactive Financial Model With an Investor (Securely)"
lang: en
canonical_url: https://www.peony.ink/blog/share-financial-model-with-investor
description: "Emailing an .xlsx leaks your formulas and dies the moment an investor edits a cell. Here's how to share a live, interactive financial model with a VC while keeping per-viewer control — NDA gate, analytics, instant revoke."
date: "2026-06-29T12:00:00.000Z"
last_updated: "2026-08-21T12:00:00.000Z"
author: "Sean Yu"
---

I'm Sean Yu, co-founder of Peony. I've sat on both sides of this: the founder hitting send on a financial model at 11pm, and the investor who opens it the next morning. The single most common mistake I see in a raise isn't the model itself — it's the way it gets sent.

You spend three weeks making the numbers defensible, then you attach the `.xlsx` to an email and lose control of it in one click. The formulas, the hidden tabs, the assumption cells you meant to scrub, the comment from your last raise — all of it now lives on a stranger's laptop, forwardable to anyone, with no way to know who opened it. And the moment that investor edits a single cell, your shared source of truth quietly forks into two.

This post is about the opposite outcome: **the model that survives the send.** A live, interactive model that stays interactive for the investor — they flex scenarios, toggle assumptions, watch outputs recompute — while you keep per-viewer control: an identity-bound link, view analytics, and instant revoke. The file leaves your hands, but not your control.

I run [Peony](https://www.peony.ink/), a data room company, and we serve 8,000+ teams, a lot of them founders and CFOs in exactly this moment. So I have a point of view. I'll also tell you, honestly, where a free public link beats us — because for some sends, it does.

> **Quick answer:** Don't email the workbook. Render the model as an interactive view in a secure viewer and send each investor an identity-bound link. They still flex the model live; you keep screenshot protection, page-level analytics, and instant revoke. The file effectively leaves your hands but not your control.

![Emailing an .xlsx versus sharing a live model in a secure viewer — a row-by-row comparison of what you lose with email and what you keep with an identity-bound viewer.](https://www.peony.ink/images/blog/share-financial-model-with-investor-secure-share.png)

## What goes wrong the moment you email an .xlsx to an investor?

You lose the three things that matter most: secrecy, control, and a single source of truth.

An emailed workbook is the most leaky way to share a model that exists. Here's everything that walks out the door with it:

- **Your live formulas and logic.** The investor doesn't just see your outputs — they see exactly how you built them. Every formula, every circular reference you fought, every fudge factor.
- **Your hidden tabs and assumption cells.** Most models carry a graveyard of hidden sheets: an old scenario, a different cap table, notes to yourself, sometimes another investor's terms. "Hidden" in Excel means "right-click, unhide."
- **Forwardability with no trail.** A file has no link to expire and no identity attached. It can be forwarded to a competitor, an associate, or a friend "for a sanity check," and you'll never know.
- **The single source of truth.** This is the subtle one. The instant the investor changes a growth rate in their copy, their model and yours diverge. On the follow-up call you're each looking at different numbers and don't realize it.

A dead `.xlsx` snapshot is also just a worse experience for the investor. Half of them will open it, see a wall of tabs, and bounce. The other half will start "improving" it — and now you're defending a version of your own model you never built.

> If you instead want to know how to _build_ the model itself — the tabs, the waterfall math, the Excel mistakes that get a model rejected — that's a different post. See [Independent Sponsor Financial Model](https://www.peony.ink/blog/independent-sponsor-financial-model). This post is strictly about _sharing_ one you've already built.

## What does it actually mean to keep a model "interactive" when you share it?

It means the recipient can change inputs and watch the outputs recompute — live, in their browser — without you handing over the underlying file.

This is the heart of "the model that survives the send." A great model isn't a number; it's a machine. The investor's whole job is to turn the dials: bump CAC, cut the growth rate, push the exit out two years, and see whether the thing still holds. A PDF can't do that. A screenshot can't do that. A flattened export of your model is just a photograph of a machine that no longer runs.

In 2026, more and more of these models are built or rendered as interactive HTML — whether you exported a scenario tool from your spreadsheet, or you built the whole thing in Claude or GPT as a live calculator or dashboard. That's a genuinely better artifact to put in front of an investor: it invites them to interrogate the model instead of just reading it. (Built yours in ChatGPT? The [ChatGPT canvas sharing guide](https://www.peony.ink/blog/how-to-securely-share-chatgpt-canvas) covers getting it out as a single .html file and past the native link's login wall.)

The problem is sharing it. Here's the trap most people hit: **most secure-sharing tools either reject `.html` outright or convert it to a PDF on upload.** The app dies. The toggles stop toggling. The investor opens your live model and finds a static image of it.

This is where I'll be specific about what Peony does, because it's the core reason this post exists. Peony renders `.html`/`.htm` natively in the in-browser viewer **with JavaScript executing** — so a live, AI-built or spreadsheet-derived interactive model actually runs for the recipient. They change an assumption; the outputs recompute, right there in a viewer you control. Most tools can't do this. We can. (The product detail lives on the [HTML viewer page](https://www.peony.ink/features/html-viewer) if you want the mechanics.)

## How do you share a financial model with an investor while keeping control?

You stop sharing a _file_ and start sharing an _identity-bound view_. The view carries your controls with it.

Here's the practical sequence I'd run if I were sending one model to investors tomorrow:

1. **Render the model as an interactive view, not a workbook.** Either export your scenario layer to HTML, or, if you built it in an AI tool, share the live artifact directly. The goal is that the investor can flex it without ever holding the `.xlsx`.
2. **Issue each investor their own link, tied to their name and email.** Not one link for everyone — one per person. This is the single decision that makes everything downstream possible: attribution, analytics, and selective revoke all depend on it.
3. **Turn on the controls that match the sensitivity of the model.** Peony doesn't draw the per-viewer watermark over the live render, so if you want a copy that carries each investor's name, email, and a timestamp, upload a watermarked PDF export beside the live model. Download prevention and screenshot protection raise the cost of exfiltration. NDA gating puts a click-through wall in front of access. Granular per-file and per-link permissions let you show one investor the full model and another a trimmed version.
4. **Watch the analytics, then follow up precisely.** You'll see who opened the model, which scenarios they stressed, and for how long. A cold "just following up" becomes "I saw you spent time on the downside case — want to walk the churn assumption?"
5. **Revoke the instant anything changes.** Round oversubscribed, a term sheet signed, an investor passes — kill their link without touching anyone else's.

That's the whole argument in five steps: **the file leaves your hands but not your control.** A public link can't do step 2 onward, which is why it can never run a real diligence process.

> If you're not sending a single model but standing up the _whole_ fundraising room — cap table, incorporation docs, financials, customer contracts, the full diligence inventory — that's a bigger job. See [Data Room for Investors](https://www.peony.ink/blog/data-room-for-investors) and, for a priced round specifically, [Series A Data Room](https://www.peony.ink/blog/series-a-data-room). This post is the single act of sharing _one_ live model; those are the room.

## ShareDuo, Stacktree, public links, or a data room — what should you actually use?

It depends on how confidential the model is and whether you need to know who looked at it. Let me be genuinely fair here, because the honest answer makes the choice clearer.

**ShareDuo and Stacktree are real, good tools, and for some sends they win.** Both let you publish an AI-built artifact to a fast, public-or-unguessable link — free or cheap, no login for the viewer — with a password and an expiry date. Stacktree even has an MCP publish flow with update-in-place, so you can revise the model and the same link reflects it. If your goal is "get a live, interactive model in front of someone in 30 seconds with zero friction," they are excellent, and I'd genuinely use them for a non-confidential teaser.

What a public or unguessable link **fundamentally cannot do**, no matter how good the tool:

- **Bind the view to a named investor.** A password is shared the moment it's useful; it identifies no one.
- **Add screenshot protection or an access log.** Everyone sees the same anonymous, unprotected render, so a leak has no signature.
- **Gate on an NDA** before the model loads.
- **Show you analytics** on who opened it and what they looked at.
- **Revoke one person** after the fact without breaking the link for everyone.

That's the whole distinction: a public link is **sharing a file**; an identity-bound view is **running a diligence process**. Google Sheets "anyone with the link" and a raw DocSend send sit on the file side of that line too — convenient, but anonymous.

Peony's edge is deliberately upmarket and deal-grade. We're not trying to win the free-public-link race; we lose that one on purpose. We win when the model is confidential, the investors are named, and you need to be able to prove who saw what and shut it off. That's the trade, stated plainly.

## Where does Peony lose — and where does it win?

Peony loses on free, frictionless, public sharing, and it's not the tool for _building_ the model. It wins on identity-bound, deal-grade control over a live model.

I think conceding this clearly is more useful than a feature dump, so:

**Where Peony is the wrong tool:**

- **You want a free, no-login, public link in 30 seconds.** Use ShareDuo or Stacktree. We require a more deliberate, identity-bound setup by design.
- **You haven't built the model yet.** Peony shares models; it doesn't build them. For the architecture and formulas, start with [the financial model build guide](https://www.peony.ink/blog/independent-sponsor-financial-model).
- **You want clause-level citations, a public REST API and CLI, or to self-host the whole thing on your own servers.** Those are explicitly not us — I'd rather tell you than have you discover it later.

**Where Peony is the right tool:**

- The model is confidential and the investors are **named** people you can attribute a view to.
- You need the model to **stay live** — JavaScript executing in the viewer — not flattened to a dead PDF.
- You need **screenshot protection**, page-level **analytics**, NDA gating, and **instant revoke** in one place.
- You'd like to build the model in Claude and **push it straight into a gated, revocable room via the MCP server** without re-uploading.

With 8,000+ teams, a large share of what we see in fundraising is exactly this single, high-stakes send. It's a small action with an outsized downside if you get it wrong.

## What does it cost, and is the live-render feature locked behind Enterprise?

It's affordable for a single raise, and no — keeping your model interactive is **not** an enterprise-only feature. That's the question I get most, so I'll answer it directly.

Native HTML rendering — the thing that keeps your model actually running for the investor — works **across tiers**. You do not need an enterprise contract to keep your model interactive. Here's the canon:

| Plan       | Price           | What you get for sharing a model                                                               |
| ---------- | --------------- | ---------------------------------------------------------------------------------------------- |
| Free       | $0              | Get started; native HTML rendering included                                                    |
| Business   | $30/admin/month | Screenshot protection, download prevention, NDA gating, page-level analytics                   |
| Data Room  | $52/admin/month | Adds per-viewer **dynamic watermark** and mobile screenshot blocking (Screenshield)            |
| Deal Team  | Higher          | For larger deal teams                                                                          |
| Enterprise | Custom          | Connect your own GPT + Claude + Gemini under zero-retention, permission-scoped, audited access |

For most founders sharing a model in a raise, the **Data Room plan at $52/admin/month** is the landing spot, because granular per-investor permissions, the Advanced NDA and Screenshield are the controls that make a confidential model safe to send to multiple investors at once. The full breakdown is on [pricing](https://www.peony.ink/pricing).

One more capability worth knowing about, because it changes the workflow: the **Peony MCP server is publicly available now**, and it's bidirectional — an AI agent can read room contents and push an artifact _into_ the room. So you can build the interactive model in Claude, install the MCP, and push it directly into an NDA-gated, tracked, revocable room without leaving the chat. And at the Enterprise tier, you can connect your own GPT, Claude, and Gemini to the room under zero-retention and permission-scoped access — the model sees only what the viewer is allowed to see — with every AI query and document access logged.

## The bottom line: send the model, not the file

The mistake isn't your model — it's the `.xlsx` attachment. Emailing the workbook leaks your formulas, exposes your hidden tabs, hands over a forwardable file, and forks your source of truth the instant someone edits a cell. None of that has to happen.

Share the model as a **live, interactive view bound to a named investor** instead. They get to flex it; you keep screenshot protection, page-level analytics, and instant revoke. If the model is confidential and the investors are named, that identity-bound control is the difference between sharing a file and running a process. If it's a casual, non-confidential share, a public link from ShareDuo or Stacktree is genuinely fine — I'd use one myself.

For the [secure, deal-grade version](https://www.peony.ink/solutions/fundraising) — the model that survives the send — that's what we built Peony for. 8,000+ teams, and counting.

## Related resources

- [How to Send a Live Dashboard to a Client Securely](https://www.peony.ink/blog/share-live-dashboard-with-client) — the consultant-and-client version of this same live-vs-flattened problem.
- [How to Share an Interactive ROI Calculator With a Prospect (Securely)](https://www.peony.ink/blog/share-roi-calculator-with-prospect) — the B2B-sales version: keep a live business-case calculator interactive without leaking your pricing logic.
- [How to Share an Interactive LP Report With Your Limited Partners (Securely)](https://www.peony.ink/blog/share-interactive-lp-report) — the fund-IR version: send a live quarterly LP report to each named limited partner under per-LP control.
- [How to Share an Interactive Board Report With Your Directors (Securely)](https://www.peony.ink/blog/share-interactive-board-report) — the governance version: send a live board report to directors under per-director tracked links and a confidentiality gate.
- [M&A Valuation Methods (2026)](https://www.peony.ink/blog/ma-valuation-methods) — the DCF, comps, and accretion/dilution math the model you are sharing actually feeds.

---

_Disclaimer: This article is for general informational purposes and is not legal, financial, or investment advice. Plan names, prices, and features reflect Peony's offering as of June 2026 and may change — confirm current details on the [pricing page](https://www.peony.ink/pricing). Always consult qualified counsel before sharing confidential financial materials in a fundraising or M&A process._

## Sources

- Peony product documentation and plan details — [Pricing](https://www.peony.ink/pricing), [HTML viewer](https://www.peony.ink/features/html-viewer), [Watermarks](https://www.peony.ink/features/watermarks), [Page analytics](https://www.peony.ink/features/page-analytics), [Revoke access](https://www.peony.ink/features/revoke-access) (accessed June 2026).
- ShareDuo — shareduo.com, public AI-artifact sharing with password and expiry (reviewed June 2026).
- Stacktree — stacktr.ee, public artifact publishing with MCP publish-and-update-in-place flow (reviewed June 2026).
- Model Context Protocol (MCP) — open standard for connecting AI agents to external tools and data sources; Peony MCP server, publicly available 2026.
- Related Peony guides: [Independent Sponsor Financial Model](https://www.peony.ink/blog/independent-sponsor-financial-model), [Data Room for Investors](https://www.peony.ink/blog/data-room-for-investors), [Series A Data Room](https://www.peony.ink/blog/series-a-data-room), [Seed Round Data Room](https://www.peony.ink/blog/seed-round-data-room), [Fundraising solutions](https://www.peony.ink/solutions/fundraising). Task walkthrough: [share a financial model without sending the file](https://www.peony.ink/use-cases/share-financial-model).

## FAQ

### How do I share an interactive financial model with an investor securely?

Don't email the workbook. Render the model as an interactive view inside a secure viewer and send each investor an identity-bound link instead of a file. That way the investor can still flex scenarios and watch outputs recompute, but you keep control: screenshot protection and an NDA gate guard the live render, you see page-level analytics on who opened it and which scenarios they touched, and you can revoke access instantly if the round changes. Peony renders .html/.htm natively in the browser with JavaScript executing, so an AI-built or spreadsheet-derived interactive model actually runs for the recipient rather than collapsing to a flat PDF — see the [HTML viewer](/features/html-viewer) for how that works.

### Should I email my Excel model to a VC, or share it through a secure viewer?

Share it through a secure viewer. The moment an .xlsx leaves your outbox, you've handed over your live formulas, your hidden tabs, your assumption cells, and a file the investor can forward to anyone. A secure viewer sends a link bound to a named person instead — the investor interacts with the model, but the underlying workbook never lands on their desktop. For a single model going to a handful of named investors, Peony's [Business plan](/pricing) at $30/admin/month already gives you screenshot protection, download prevention, and page-level analytics; the [Data Room plan](/features/watermarks) at $52/admin/month adds the per-viewer dynamic watermark.

### If I email an .xlsx, can the investor see my formulas and assumptions and forward it?

Yes — all of it. An emailed workbook exposes every formula, every hidden tab, every assumption cell, and any other-investor terms you forgot to scrub. It's also trivially forwardable: there's no link to expire, no identity bound to the file, and no way to know who opened it or who passed it on. Sharing the model as a rendered view inside a secure viewer keeps the raw workbook in your hands while the investor still gets to use it. Peony's [granular per-file and per-link permissions](/features/revoke-access) let you decide exactly who can open which version, and revoke any of them after the fact.

### What actually happens when an investor edits a cell in the model I emailed them?

The shared truth forks. The instant an investor tweaks a growth rate or a churn assumption in their copy, their numbers and yours diverge — and on the follow-up call you're debating two different models without knowing it. An emailed file is a dead snapshot the moment it's opened. A live model shared through a viewer stays a single source of truth: the investor flexes scenarios against the model you published, and if you push an update, every viewer sees the same current version. Peony's [page-level analytics](/features/page-analytics) even show which scenarios each investor stressed, so the call starts where their questions actually are.

### Can the investor still flex and play with the model, or does a secure viewer flatten it to a PDF?

It depends entirely on the tool — and this is where most data rooms quietly fail. The majority of secure-sharing tools either reject .html outright or convert it to a PDF, which kills the interactivity: the toggles stop toggling, the outputs stop recomputing, and the investor is staring at a screenshot of a model. Peony renders .html/.htm natively in the browser with JavaScript executing, so a Claude-built, GPT-built, or spreadsheet-derived interactive model actually runs for the investor — they change assumptions and watch the outputs recompute live, inside a viewer you control. The [HTML viewer](/features/html-viewer) is the core differentiator here.

### How do I share my Excel model without losing control of the file?

Stop thinking in files and start thinking in identity-bound views. Convert or rebuild the model as an interactive view, then issue each investor a link tied to their name and email rather than handing over a workbook. The view carries your controls with it: download prevention, screenshot protection, NDA gating before access, and instant revoke, with the per-viewer watermark on any PDF version you send alongside. The file effectively leaves your hands but not your control. Peony's [revoke-access controls](/features/revoke-access) let you cut off any single investor's link the moment a process changes, without recalling anything from anyone else.

### How do I see which investor opened my model and which scenarios they looked at?

Use page-level view analytics — the single biggest advantage of a viewer over an email. Instead of wondering whether an investor read the model, you see who opened it, which pages or scenario tabs they spent time on, and how long they stayed. That turns a cold follow-up into a precise one: you already know the partner spent six minutes on the downside case. Peony's [page-level analytics](/features/page-analytics) attribute every view to a named, link-bound investor, so you know exactly where interest is concentrated before you pick up the phone.

### If my model leaks, can I tell which investor leaked it?

On a live model, your forensic trail is the identity-bound link: each investor's named link, NDA record and access log show exactly who opened it and when. Peony doesn't draw the per-viewer watermark over the live HTML render itself; if you want the image to carry each investor's name, email, and a timestamp, send a watermarked PDF export beside the live model, so a screenshot or photo of that copy carries the leaker's identity. The honest caveat: a watermark is attribution and deterrence, not capture-prevention — a determined viewer can still photograph a screen, but now they're photographing their own name. Peony's [dynamic watermark](/features/watermarks) (Data Room plan and above) is identity-bound per viewer, which is exactly what a public, anonymous share link can never give you.

### Is a public Claude/ChatGPT or ShareDuo/Stacktree link safe enough for my investor model?

For a quick, non-confidential share, those tools are genuinely good — and I'll credit them. ShareDuo and Stacktree both publish AI-built artifacts to fast, free-or-cheap links with password and expiry, and Stacktree even has an MCP publish-and-update-in-place flow. If you just want to get a live model in front of someone with no login friction, they win that use case. What a public, unguessable link cannot do is bind the view to a named investor, block screenshots, gate on an NDA, show you who viewed what, or revoke one person's access after the fact. That identity-bound control is the line between sharing a file and running a diligence process — and it's where Peony's [data room](/) is built to operate.

### How much does it cost to share a financial model securely with investors?

Less than most founders expect, and live rendering is not gated behind an enterprise contract. Peony is Free at $0 to start, Business at $30/admin/month (screenshot protection, download prevention, NDA gating, page-level analytics), and Data Room at $52/admin/month, which adds the per-viewer dynamic watermark and mobile screenshot blocking — the tier most fundraising founders land on. Deal Team sits above that, and Enterprise is custom. Crucially, native HTML rendering works across tiers, so you don't need an enterprise deal to keep your model interactive. See [pricing](/pricing) for the full breakdown.

### Can I build the model in Claude and push it straight into a secure room without re-uploading?

Yes — that's exactly what the Peony MCP server is for, and it's publicly available now. The MCP server is bidirectional: an AI agent can both read room contents and push an artifact into the room. So the workflow is: build the interactive model in Claude, install the Peony MCP, and push it straight into an NDA-gated, tracked, revocable room without ever leaving the chat or exporting a file. For teams that want to go further, Peony's [Enterprise plan](/pricing) lets you connect your own GPT, Claude, and Gemini to the room under zero-retention, permission-scoped, audited access — every AI query and document access is logged.

---

_Markdown version of [https://www.peony.ink/blog/share-financial-model-with-investor](https://www.peony.ink/blog/share-financial-model-with-investor.md) for AI agents and LLMs; canonical HTML: https://www.peony.ink/blog/share-financial-model-with-investor. Every page on peony.ink is available as markdown — append `.md` to the URL or request it with `Accept: text/markdown`. More: [llms.txt](https://www.peony.ink/llms.txt)._