Real-time collaboration, 97% faster

Joining a session

Click an invite link, choose your path, land in the session. No downloads, no friction.

Viewing & navigating documents

Pan, zoom, move between sheets. See who else is here with real-time presence indicators.

Leaving markups

Add comments, callouts, annotations — the core collaboration act. Markups appear in real-time for everyone.

Creating a Session

Start a new Session directly from the browser. Name it, invite collaborators, and begin working together — no desktop app required.

Managing files

Import documents from other locations, download copies, delete files you no longer need. Full file management without leaving the browser.

"Just send me a link."

This phrase tells the whole story. From 2011 to 2018, search interest in "send me a link" grew steadily — then accelerated sharply after 2019. ^[1] Link-based access became the default expectation. Asking someone to download software to view a file started to feel like asking them to fax it.

Hypothesis: Link-based access has become the default user expectation.

Measured by: Time to open — how long from clicking an invite to landing in a session.

Customer demand

Our research confirmed it: users wanted platform-agnostic collaboration. 71% of U.S. employers had moved to hybrid work models. ^[5] Construction teams were distributed across offices, jobsites, and home — and 22% of job candidates now cited flexible work arrangements as important to their decisions. ^[3] They didn't care about our product architecture — they just wanted to work with their people, on whatever device they had.

Hypothesis: Users want platform-agnostic collaboration — they'll go elsewhere if we don't provide it.

Measured by: Feature request volume for web/mobile access; session abandonment rate when Revu isn't installed.

A closing window

Bluebeam was sunsetting both the iPad app and Revu for Mac. The answer to mobile and Mac was clear: Bluebeam Cloud, the web product. But Cloud didn't connect to Sessions — the feature that made Revu sticky. Without that bridge, Revu users had no reason to touch Cloud, and Cloud users couldn't participate in Sessions.

Meanwhile, the generational math was shifting. Over 24 years, Mac usage among students climbed from under 10% to over 40%, while Windows dropped from 90% to roughly 50%. ^[9] Nearly half of today's AEC students use Macs — a sea change from a generation ago. The future architects and engineers entering the workforce expect Mac support, because it's what they know. Windows-only wasn't just inconvenient; it was a generational risk.

Hypothesis: Without action, Bluebeam's collaboration story would fragment — or disappear.

Measured by: iPad app MAU decline; Cloud-to-Sessions cross-engagement rate.

Competitors had already moved

By 2024, 63% of construction software deployments were cloud-based — and growing faster than on-premises alternatives. ^[4] Procore was 100% browser-native with 1.3 million users. ^[6] Autodesk acquired PlanGrid for $875M and made it fully browser-accessible. ^[7] The installed desktop app was becoming the exception, not the rule.

Hypothesis: Browser-native collaboration is now table stakes — desktop-only is a competitive liability.

Measured by: Competitive loss rate citing "ease of access" or "no download required."

The opportunity

Sessions was the feature that made Revu sticky — the reason teams stayed on the platform. Bringing it to the web would give customers the platform-agnostic access they were demanding, replace the dying iPad app, and connect Revu and Cloud through the feature people actually cared about.

Hypothesis: Sessions is the wedge — bringing it to web solves customer demand, replaces the iPad app, and unifies the product suite.

Measured by: Web session participation rate; new Cloud users acquired through Sessions invites.

What belongs in the web experience?

This wasn't about rebuilding Revu in a browser. We had to decide what mattered for the users who'd actually be joining via web.

We used the 80/20 rule: 20% of the features would deliver 80% of the value for collaborators. We cut aggressively.

The legacy tech stack reinforced this. Revu and Studio Sessions are built on aging technology — certain features couldn't be ported, and some interactions had to be reimagined rather than replicated. We weren't building Revu in a browser. We were building a focused collaboration tool for a different type of user.

This framing kept us focused. Every feature request got filtered through: "Is this for a collaborator, or an expert?"

The landing page is the front door.

When a user clicks an invite link, what should happen? I explored three approaches:

Before: Blank page, cryptic text, OS popup

After: Landing page with "Join in Revu" / "Join in Web"

Why choice won: Safari.

When you fire a custom URI like bluebeam://join and the app isn't installed, browsers handle it differently. Chrome fails silently — nothing happens. Safari shows an error. Neither is great, but Safari's error was worse: it looked like something broke.

Safari accounts for roughly 1 billion users globally, including over half of U.S. mobile traffic. ^[8] We couldn't auto-fire and hope for the best.

Every entry point is a promise.

Users don't enter sessions from one place. They come from invite emails, alert notifications ("Sarah commented on your markup"), direct links, and 9-digit session codes — something you could read over the phone or write on a whiteboard. (Code entry existed in Revu; we descoped it for web V1.)

Each entry point carries a different promise:

• Invite email: "You'll land in this session."
• Alert email: "You'll land on this specific markup."
• Direct link: "This URL will get you there."
• Session code: "Type this and you're in." (descoped for this initiative)

Breaking that promise breaks trust. If someone clicks an alert about a markup and lands on the session homepage instead of the markup itself — that's a failure, even if they're technically "in."

The design challenge: the web doesn't preserve context well. Redirects lose state. Browser handoffs drop parameters. App switching is unpredictable. I mapped every entry-to-destination path and designed a system that honors the original intent, regardless of how chaotic the journey gets.

The URL isn't just an address — it's carrying payload: intent, destination, and permissions context. Lose any of it, and you've broken the promise.

Presence enables collaboration — but too much presence kills focus.

In Figma, cursors show where people are working — it's a workspace. You're creating together. Cursor movement is signal: "I'm iterating on this component," "I'm exploring over here."

Sessions is different. The document is a source of truth representing something physical being built. You're not creating together — you're reviewing, annotating, and deciding together. The question isn't "where are they designing?" It's "what are they looking at?" and "do they agree?"

Cursors answer "what are they looking at?" Markups answer "do they agree?" We stream both in real-time — attention and judgment, unfolding together.

But Sessions isn't collaborative design. It's design review — a formal process where stakeholders inspect documents and commit decisions to the record. A markup isn't a suggestion to riff on. It's "this dimension is wrong" or "verify in the field." When you see a cursor hover, then a markup take shape stroke-by-stroke, you're not watching someone brainstorm. You're watching a decision get made.

Why real-time? Because even formal processes have conversation. You see a colleague flag something — and you can weigh in before it's final. You avoid duplicating observations. Questions get resolved in the moment, not in follow-up email chains. The review is formal. Real-time makes it faster.

Policy before pixels.

Before designing any UI, I defined the policy layer: what's allowed, what's forbidden, and what happens when things go wrong.

Defining these rules first meant the UI had a job to do: communicate the policy, not invent it. This prevented weeks of "wait, what should happen here?" debates during implementation.

Graceful degradation: designing for when things go wrong.

At scale, edge cases aren't edge cases — they're daily occurrences. With redacted MAUs and redacted million markups per day, every "unlikely" scenario becomes someone's Tuesday.

I designed flows and UI for dozens of failure states — what the user sees, what they can do next, how we communicate what happened.

User removed mid-session

Someone kicks you out while you're working. You see a clear message and a path forward — not an app crash.

Session exceeds size threshold

Some sessions are too large for the web client. We catch this before you join if possible, and gracefully exit if it happens mid-session.

Other scenarios

Press coverage

Official sizzle reel