Here's how model data moves in most practices, right now, in 2026.

• A director asks how many bedrooms are in the current scheme.
• Someone opens Revit. Waits for the model to load.
• Builds a schedule. Exports it to Excel.
• Cleans the Excel, because the parameters are inconsistent.
• Pastes it into a slide.
• The model changes on Thursday. The slide is now wrong. Nobody tells the director.

It repeats across disciplines.

The problem isn't Revit. Revit is good at what it does. The problem is that the data lives inside a proprietary file, behind a licence, on a server, in a format that only one application can read.

It has four costs a BIM Manager feels every day:

1. Licence gating. To see the model, you need the software. So estimators, planners, clients and directors get PDFs instead of data.
2. Manual extraction. Every question becomes an export. Exports are like cars. The value drops the moment it leaves the dealership. The export is out of date the moment it's exported.
3. No provenance. 'Which version was this from?' is unanswerable in a spreadsheet.
4. No reuse. The effort you spent modelling project 14 does nothing for project 15.

In theory, BIM models contain everything needed for estimation and planning. In reality, getting that data into a usable form takes a lot of manual effort.

The gap is the business case for Speckle.

Speckle is an open data platform for AEC. It moves design data between tools without files, stores it in the cloud as versioned objects, and makes it available in a browser and through an API.

That's the definition. Here's the mental model.

Think of what Git did for code. Before Git, developers emailed each other zip files called `final_v3_ACTUAL.zip` or something of that nature. Git replaced that with a shared repository where every change is tracked, every version is retrievable, and everyone works from the same source.

Speckle does that for 3D and BIM data.

It works through connectors. Lightweight plugins that install into the software you already run. You hit Publish. The connector pulls the geometry and the metadata out of your model and sends it to Speckle. No export. No file.

Once it's there, three things become true that weren't true before:

• It's viewable by anyone with a browser. No Revit licence. No plugin. A link.
• It's versioned. Every publish is a new version. You can see what changed, when, and who did it.
• It's queryable. The objects and their parameters are data now. You can chart them, check them, or pull them into anything with an API.

The company behind it is AEC Systems Ltd, founded by Dimitrie Stefanescu, who started Speckle as part of his PhD research at the Bartlett School of Architecture, UCL, funded through the EU's InnoChain project. It grew from a research side-project into a venture-backed platform. As of 2026 the homepage claims 146,000+ projects managed across 11,800+ organisations, with Arup, Ramboll, SOM, Perkins&Will, Sasaki, Multiconsult and Herzog & de Meuron on the customer wall.

The origin matters. Speckle was built by an architect who was annoyed at file formats, not by a vendor protecting one.

If you learn one thing here, learn this. It's the concept that separates people who get Speckle from people who bounce off it.

A file is a container. An object is a thing.

When you export an IFC, you produce a container. It's a snapshot. It has a date on it. To find out what's inside, something has to open the whole container and read it.

Speckle doesn't do containers. It decomposes the model into individual objects. This wall, this room, this beam. Each carrying its own geometry and its own parameters, each with an ID, each versioned.

Three consequences follow, and they're the reason the platform works.

1. One. You can send part of a model. You don't publish 'the file'. You publish the structural frame, or just the rooms, or just level 3. Consultants receive what's relevant instead of everything you have.
2. Two. You can have different versions. Because objects have identity, Speckle can tell you what changed between version 12 and version 13 at element level. The file isn't different, the version is.
3. Data and geometry stay married. This is the big one. In most workflows you either get a picture or you get a spreadsheet. Speckle keeps them attached. So when a dashboard says '17 rooms fail the area requirement', you can click the number and see those 17 rooms highlighted in 3D.

Ye, it's pretty cool.

A data layer is only as useful as its edges. Here are Speckle's, as of 2026.

Three details a BIM Manager should note:

• The Revit connector got serious. Revit 2022 through 2026. It publishes geometry once and creates lightweight instance proxies for repeats. It matters on a tower with 400 identical units. Materials match by name on receive, so you stop collecting duplicates across sync cycles.

• There's a Revit file importer. Drag a `.rvt` straight into Speckle. No connector. No Revit licence. For a BIM Manager auditing consultant models, that's a useful door.

• Power BI is a first-class connector. This is what turns Speckle from a viewer into an analytics platform, the bit where Speckle gets dangerous.

This is the feature I was hunting for years. So let's be precise about it.

Speckle has a web viewer. Every model you publish gets a URL. Send that URL to a client and they open your model in a browser on a phone, a laptop, or a tablet. No install. No licence.

You can also embed it.

In the viewer, the ellipsis menu gives you two options:

• Embed URL — a direct link, for anywhere that accepts a link.
• Embed code (iframe) — for dropping into a website.

You also get viewer options: transparent background, hide controls, hide the selection panel, prevent scroll zoom, or manual load so a heavy model doesn't hammer the page on arrival. Manual load is the difference between a project page that opens instantly and one that hangs for eight seconds.

• On security: because someone in your office is about to ask. Sharing a link doesn't make a private project public. Regular links still follow project visibility and role permissions.
• For external sharing there are secure share links: create a token, set an expiry date, add a password, label it `Client review`. Every token sits under Project settings → Tokens, and you can revoke any of them.

So: a client sees the live model, in a branded page, for two weeks, and then the link dies.

This is what bimcopilot.com runs on. The 3D you see on the site is a Speckle embed, fed from a model, updating when the model updates. The thing I couldn't build in 2016 is now pretty easy.

The viewer is the part people notice. The data is the part that changes how a practice operates.

Every object you publish carries its parameters. Speckle exposes those parameters, which means you can chart them . Because Speckle keeps geometry and data attached, the charts and the model talk to each other.

There are three routes, and choosing between them is the main architectural decision a BIM Manager makes here.

• Route one: Power BI: The mature option. Publish from Revit, load into Power BI through the Speckle connector, expand the object properties, build your visual. The Speckle Power BI visual renders the actual 3D model inside the Power BI report, colour-coded by whatever you're measuring.

This is how HENN did it, and how Sisk did it. It's flexible, it's powerful, and it requires someone who knows Power BI.

• Route two: Speckle Intelligence dashboards: Speckle's own analytics layer, and the newer bet. Interactive dashboards inside Speckle, no BI tool required, with an AI query layer on top. ask 'make me a space report for the ground floor' or 'compare wall areas across all Revit models' and get an answer with the elements highlighted.

Speckle are explicit that this isn't a black box: queries resolve to inspectable, reusable logic your team can validate. Worth checking, because 'AI for BIM' is a crowded field of things that hallucinate quantities.

The trade-off is adoption. GBI found Power BI too complex to scale past a small technical group. Engineers took around three days to onboard. With Speckle Intelligence, most became productive in about 30 minutes.

That's the real argument for route two. Not that it's more powerful. That more people will use it. In architecture, adoption is almost always the win.

Route three: build it yourself: I like this one, I'm using it right now. The possibilities are endless. GraphQL API, Python SDK, Viewer API, npm packages, and a dev mode exposing the raw JSON of any object. If you have a developer, or you are one. Speckle is infrastructure rather than an app. Suffolk and Pomerleau both went this way.

For a BIM Manager this may be the section that matters most, because model quality is the thing you're actually accountable for.

Speckle's Model Validation runs checks the moment a model arrives. Either from a file import, a connector publish, or a CDE sync. You define rule sets for parameters, naming, classifications and codes, and apply them across projects. You can import EIR requirements to align with the standards you've already been handed.

Failed checks don't become a PDF report no one reads. They become element-level issues you can see in 3D, assign, track and close.

Speckle's own aggregate claims are 30× faster model validation and 60% fewer manual data entries. Treat vendor numbers as vendor numbers. But the pattern is corroborated by the case studies, and the mechanism is obvious: checking every version automatically beats checking some versions manually.

The important structural point is the one Speckle makes about CDEs: 'The CDE keeps your data. Speckle keeps it working.' Validation sits between authoring and delivery, not instead of either.

One honest caveat, repeated later: Speckle Automate, the engine for custom automated functions, is on the Enterprise plan. In-session validation is available lower down, saved and reusable checks come with Team. Cross-project rule propagation is Enterprise. Price it accordingly.

Enough theory. Here's what firms have done with it. Most of these are Speckle's own published customer stories. Read them as best cases, not averages.

HENN — winning a hospital bid with a 3D dashboard

HENN, a 400-person practice across Munich, Berlin, Frankfurt and Shanghai. Bid the Hanover Medical School extension with C.F. Møller. Site area 137,000 m². Usable area 46,600 m² in phase one.

The client's requirement was brutal: BIM models only, no traditional plan submission, all requirement checks automated. Errors in the model data could mean disqualification.

Revit doesn't visualise rooms in 3D natively. IFC export was too slow for a competition programme.

The team published to Speckle, pulled it into Power BI, expanded the room objects, and cross-referenced room names, numbers, designed areas and departments against the client's requirements. The dashboard showed a live 3D model with filterable tables and compliance checkmarks.

The design director, project leader and consultants all had access. None of them opened Revit.

"We didn't need any onboarding for the team. They just had to click the 'Publish to Speckle' button, and the dashboard would update."

Emiliano Lupo, Design Technology, HENN

Why this matters to you: this is the competition-stage use case. Fast, disposable, high-stakes. It requires one person who can build a dashboard.

Pomerleau — 59,000 pieces of equipment, and the honest version of a rollout

The most useful case study here, partly because Pomerleau are candid that it isn't finished.

On a large Quebec healthcare project they needed to validate specialised equipment across Revit, dRofus and Documatic against monthly client-issued lists. Roughly 59,000 equipment items. 6,700 rooms. 12 levels. All three datasets evolving independently.

They built on Speckle rather than buying a tool.

Around 60% fewer manual data entries. Dashboards refreshed daily instead of weekly. Licence costs for field users dropped to zero. They built their own tools on top — a QA/QC Checker Pro, a Speckle BI Extractor — shipping roughly one internal tool a week at peak.

And here's the honest part, in their own framing: this is a structured transformation programme, not a completed rollout. Phased. Pilot projects first. Governance standards, naming conventions, property set normalisation and validation rules still being written.

Why this matters to you: this is what a real enterprise deployment looks like. Not a big-bang switch. A pilot, then standards, then scale. If you're building a business case, use Pomerleau's shape, not their numbers.

Herzog & de Meuron — the practice-scale version

550 people in Basel. Tate Modern, UCSF, Alpine work. Enormous project diversity, and a design process they describe as chaotic and non-linear.

Their split is elegant: raw model data in Speckle, processed data in Directus. No duplication. They build 3D dashboards combining spatial and performance metrics, take standardised project snapshots at milestones so projects can be compared over time, and run an in-house CALC LCA tool that estimates embodied carbon from an assembly library.

Why this matters to you: the snapshot idea transfers to any practice, at any size, this month. Publish at the end of each stage. Now you have a comparable record of every project you've ever done — institutional memory in a form you can query.

In the [Notion post] https://bimcopilot.com/blog/notion-for-architects-how-small-practices-run-the-whole-studio-and-use-ai-to-do-it-2026,

I argued the practice should run on one workspace:

• The Brain.

• The Pipeline.

• The Projects.

• The Design layer.

• The Client layer.

Speckle is the piece that makes that workspace 3D and interactive.

This is the mental model, stacked:

The bit that takes two minutes:

Speckle publish an official Notion tutorial for this, so it's a supported path, not a hack.

1. Open the model in Speckle. Click the ellipsis (⋯) top right of the viewer

2. Choose Embed Model, then Embed URL. Copy.

3. In Notion, type `/embed`, hit Enter, paste, click Embed Link.

Your live model now sits inside the Notion project page. When someone republishes from Revit, the embed reflects it in real time.

Put that on the project page and something changes.

• The brief.

• The decisions log.

• The material spec.

• The deliverables list.

• The actual building are on one screen.

A project meeting stops being three apps.

The bit that takes an afternoon:

Now wire the data in. This bit's trickier, but not that tricky.

Model health into a Notion database. Speckle's GraphQL API and Python SDK let you read validation results, version history, object counts and parameters.

A short script. The same `requests` pattern as the pyRevit-to-Notion bridge https://bimcopilot.com/blog/pyrevit-automation-where-to-start ,. writes those numbers into a Notion database. One row per project. Warnings, failed checks, last publish date, who published. Or whatever you want really.

Every project's model health, in the same workspace as the standards those checks enforce. It's a genuinely useful thing for a BIM Manager to have on a Monday morning.

Trigger it automatically:

On Enterprise, Speckle Automate runs serverless functions when a new version arrives. Elsewhere, a scheduled script polling the API does the same job with more duct tape.

Either way, the flow looks like this: *someone publishes from Revit → checks run → results land in Notion → the dashboard is current without anyone updating it.*

Client portals:

You already have a view-only Notion page for the client. Add the Speckle embed with a secure share link. Expiry date, password, labelled `Client review`.

They get the timeline, the deliverables, the approvals and the live model, in a browser, without an account for either tool.

The honest version of this section:

This is a system you assemble, not a product you buy. Nobody ships 'Speckle for Notion'. The embed is officially supported and takes two minutes. The data bridge is a Python script you or a colleague writes and maintains.

Worth it? If you have twelve live projects and no single place to see their health, yes. If you have three, use Speckle's own dashboards and skip the plumbing.

The failure mode with Speckle is the same as with Notion.

It's capable of so much that people try to build the enterprise data lake in week one, stall, then quietly stop.

Start narrow. This order works.

Weeks 1–2 — One model, one link.

• Free plan. Install the Revit connector on one machine. Publish one model. Send the link to one colleague who doesn't have Revit. Watch them open your building on a phone. The moment is a sales pitch and costs nothing.

Weeks 3–4 — Embed it.

• Put the viewer somewhere people already look. The Notion project page, the intranet, a client portal. Use manual load so it doesn't drag the page. Use a secure share link with an expiry for anything external. Now the model has an audience beyond the modelling team.

Weeks 5–8 — One number that matters.

• Pick a single metric your directors already ask about. Room areas against brief. Precast panels delivered. Structural tonnage. Build one dashboard on it. Speckle Intelligence if you want adoption. Power BI if you need control.

One metric. Not a dashboard suite. You're proving the pipeline, not building the product.

Weeks 9–12 — Standards, then automation.

• This is the BIM Manager's real work, and it sits at week nine rather than week one for a reason. Your dashboard will have exposed the data problems by now: the inconsistent families, the missing parameters, the naming that drifted three projects ago.

Fix the template. Write the rules. Import your EIR into Speckle's validation. *Then* automate the checks.

Do it in this order and the standards work has a visible reason. Do it the other way round and it will become another piece of technology nobody uses.

Month 4 onward — Scale on demand.

• Add projects when the pain is real. Consider the ACC sync when manual publishing becomes the bottleneck. Consider a data lake when you have a data team, and not before.

Small and used beats grand and abandoned. Pomerleau, a company with engineers to spare. They ran controlled pilots first and wrote the governance as they went. Copy that.

This is a guide. I'm not affiliated with Speckle. This is an honest rollout of Speckle's limits.

Speckle is not a CDE.

• This is the big one. Speckle does not replace ACC, ProjectWise or Asite. It doesn't hold your ISO19650 audit trail, your formal approval states, your suitability codes or your contractual issue register. It integrates with ACC. It doesn't substitute for it. Speckle's own framing is right: *the CDE keeps your data, Speckle keeps it working.* If someone in a bid is positioning Speckle as an ISO19650 CDE, correct them.

It is not an authoring tool.

• No drawing. No modelling. No clash detection in the Navisworks sense. The model stays in Revit.

Round-tripping is not lossless.

• Publishing Revit → Speckle → Revit gets you geometry and data, and native families are now supported. It is not a native BIM exchange with full parametric fidelity in both directions. Test it on your own content before you promise it to anyone.terprise is custom.

Speckle Automate is Enterprise-only.

• The automation engine, the thing that makes the 'checks run on every publish', sits on the Enterprise plan. Saved and reusable validation checks come with Team; cross-project rule propagation is Enterprise. Budget for the tier that matches the story you're telling internally.

It rewards clean data, and punishes dirty data in public.

• GBI had to clean families and parameters before the value showed up. If your models are inconsistent, Speckle will render that inconsistency beautifully, on a dashboard, in front of your directors. Plan for that.

Adoption is a real risk with the BI route.

• Three days to onboard someone to Power BI is three days most engineers don't have. If you go that route, accept that a small group will own the dashboards and everyone else will consume them.

None of this is a reason to avoid Speckle. It's the line between the jobs it's brilliant at.

• Liberating data.
• Making it visible.
• Checking it automatically.

That's it.

What is Speckle?

• An open data platform for AEC. It moves design data between tools without files, stores it as versioned objects in the cloud, and makes it viewable in a browser and queryable through an API.

Can Speckle put a live Revit model on a website?

• Yes. Every model gets a viewer URL, plus an embed URL and iframe code. Drop it into a web page, a Notion page, a Miro board or a PowerPoint slide. Viewers need no software and no licence.

Does Speckle replace my CDE?

• No. It sits beside it. Your ISO19650 audit trail, approvals and formal issue states stay in your CDE. Speckle integrates with Autodesk Construction Cloud, with Bentley ProjectWise on a waitlist.

Does it work with Revit 2026?

• Yes. The connector covers Revit 2022 through 2026. There's also a `.rvt` file importer that works without a Revit licence at all.

Do I need Revit to view a Speckle model?

• No. That's the point. A browser is enough. Desktop, tablet or phone.

Can Speckle connect to Power BI?

• Yes, with a dedicated connector, and the Power BI visual renders the 3D model inside the report. It's the backbone of most published Speckle dashboards, including HENN's and Sisk's.

Is Speckle better than IFC?

• Different jobs. IFC is an open exchange format — a container, and often a contractual deliverable. Speckle is a live data layer with versioning and an API. Use both: Speckle imports IFC. IFC is still what you hand over.

Can I embed a Speckle model in Notion?

Yes, and Speckle document it officially. Copy the Embed URL from the viewer's ellipsis menu, type `/embed` in Notion, paste. Two minutes.

Can I share a model with a client securely?

• Yes. Secure share links support expiry dates, password protection and labels. Tokens are listed under Project settings → Tokens and can be revoked at any time. A normal link does not make a private project public.

Will Speckle train AI on our models?

• Speckle address this directly in their pricing FAQ and terms, and they explicitly invite scrutiny of those terms. Read them yourself before you commit firm data — that's true of any platform, not just this one.

How long until it's useful?

• An afternoon to see value. A quarter to build a system. Publish one model and send one link this week; you'll know within an hour whether it belongs in your stack.

The Bimcopilot BIM Data Audit

We map where your model data actually goes — and where it dies in a spreadsheet.

Then we build the layer that fixes it:

• The Speckle setup — connectors, workspaces, project structure, publishing discipline
• The viewer layer — client portals, embeds, secure share links that expire
• The dashboard — one metric that matters, live, in Power BI or Speckle Intelligence
• The validation rules — your EIR, your naming, your parameters, checked on every publish
• The Notion bridge — model health, versions and 3D sitting next to your standards and your programme

Not a licence resale. A system matched to how your team actually delivers, set up so people use it.

*Get your data out of the file.*

Talk to Bimcopilot about your data layer

https://www.bimcopilot.com

• Notion for Architects: How Small Practices Run the Whole Studio — and Use AI to Do It (2026) https://bimcopilot.com/blog/notion-for-architects-how-small-practices-run-the-whole-studio-and-use-ai-to-do-it-2026

• How to Use pyRevit: The 2026 Field Manual for Architects and BIM Managers https://bimcopilot.com/blog/pyrevit-automation-where-to-start

• BIM Templates That Save Time: The ISO-19650 Template Stack for Architects and BIM Managers 2026 https://bimcopilot.com/blog/bim-templates-that-save-time-2026-template-stack-architects-bim-manager

• The Best BIM Software for Architects in 2026 (Full Comparison Guide) https://bimcopilot.com/blog/the-best-bim-software-for-architects-in-2026