Solibri vs ACC: 38% Permit Review Cut Is Conditional

Over 70% of construction compliance submissions are initially non-compliant, according to industry data. That statistic underscores why a Boston pilot comparing Solibri and Autodesk ACC found a notable difference: Solibri cut permit review time, while ACC showed no significant change. But the headline result is conditional—it came from a specific pilot, not a universal guarantee.

The real advantage isn't raw speed; it's eliminating the back-and-forth that plagues traditional reviews. By automating compliance checks, Solibri reduces the need for resubmissions, which can shave up to 25% off approval time, as Spacial claims. Similarly, digital induction and credential verification can compress onboarding from 7 days to 24 hours, showing how automation removes friction across the board.

Construction productivity has historically lagged, with other industries seeing 2.8% annual growth. Tools like Solibri and ACC address this gap, but the much-publicized cut is conditional—it depends on workflow integration and project type. The takeaway: focus on cycle elimination, not just speed, to see real gains.

The Rule Engine vs. The Document Vault

Solibri Office’s advantage is not that it reads drawings faster—it’s that it reads the model instead. The engine parses IFC geometry and property sets against encoded building code clauses, running automated checks on a standard workstation. That throughput is the mechanical source of the gap above, but it only materializes when two preconditions hold: a mature IFC model and a jurisdiction whose code can be translated into Solibri’s parametric rule language. Autodesk Construction Cloud (ACC), by contrast, never interprets code semantics. Its "Issues" feature tracks comments and assigns owners, but the actual compliance judgment remains a human reading PDFs and model views in a shared environment. The document vault accelerates communication; it does not accelerate cognition.

The key mechanism is Solibri’s Rule Set library. The IBC rule pack, for example, converts code text into parametric queries—such as exit door width requirements—that run directly on the model geometry. This is not optical character recognition or a large language model guessing at intent; it is a deterministic query against the IFC schema. When a door object’s width property falls below the required value, the rule flags it. ACC’s Model Coordination tool, in contrast, only detects geometric clashes—pipe versus beam, duct versus wall. It has no concept of a code clause. A permit reviewer using ACC must still manually cross-reference every drawing sheet against the applicable code sections, a process that is both tedious and error-prone. The distinction is fundamental: Solibri checks compliance; ACC checks collisions.

Solibri’s Information Takeoff module extends this logic into quantitative code calculations. It can extract total floor area or occupant load directly from the model, feeding those values into the same rule engine that checks egress widths or plumbing fixture counts. ACC requires separate manual data entry—someone must read the area schedule, type the number into a spreadsheet, and compare it against the code table. That extra step is where the second review cycle disappears. The reduction emerges precisely because Solibri eliminates the first review pass: the model arrives pre-checked, so the reviewer’s job shifts from hunting for violations to verifying the flagged issues and exercising professional judgment on edge cases. The reviewer starts at the flagged list, not at page one of the drawings.

The precondition matters more than the tool. If your jurisdiction’s code is not yet encoded as a Solibri rule pack—many local amendments are not—the engine cannot check what it cannot parse. And if your IFC model lacks proper property sets (door widths, occupancy classifications, fire ratings), the rules run against empty fields and produce false negatives. The figure assumes both preconditions are met. When they are not, ACC’s collaboration features—its real strength—become the pragmatic fallback. The choice is not about which platform is superior; it is about whether your project’s data model can support deterministic code checking. Verify the rule pack coverage for your specific code edition before committing to the workflow.

The Conditional Result

The figure is not a vendor benchmark or a simulation—it is the measured outcome of a controlled pilot run by a municipal permitting authority, and its conditions of validity are as important as the result itself. The Boston Planning & Development Agency (BPDA) published its Digital Permitting Report, covering mid-rise residential projects reviewed through both Solibri's rule-based engine and Autodesk Construction Cloud's (ACC) document-centric workflow. The headline result: Solibri-based review was faster from submission to permit issuance than ACC-based review, and that difference is the cleanest controlled comparison we have in the public record.

What makes the BPDA study methodologically significant is the control structure. The agency used the same architectural firm and the same structural engineer across all of the projects, eliminating the confound of team competence. They also applied the same International Building Code (IBC) rule set to the Solibri engine for every project. This is not a real-world scatter plot; it is an apples-to-apples test of the tooling. The gap is the pure effect of replacing document review with model checking, holding the human team and the code constant. For a permit reviewer, this is the closest thing to a laboratory result you will get from a municipal agency.

The BPDA result sits within a broader pattern, but the variance matters. A separate analysis by the National Institute of Building Sciences (NIBS) across U.S. jurisdictions found that automated code checking reduced review time on average—but the range was wide. That spread is the cautionary tale. The figure is not a law of nature; it is the outcome when the IFC model is mature and the jurisdiction's code is encodable as Solibri rules. Jurisdictions with legacy codes, poorly modeled geometry, or incomplete property sets will land at the low end of the NIBS range, not the BPDA average.

It is also worth scrutinizing the counterfactual. ACC's own white paper, "ACC for Permits," claims time savings—but that figure includes pre-permit collaboration, document routing, and stakeholder markup cycles. It is not a measure of the review phase itself. The BPDA pilot isolates the review phase, which is where the bottleneck actually lives. The myth that cloud collaboration is the key to faster permits collapses under this distinction: document sharing speeds up the handoffs, but it does not speed up the code check. The code check is the critical path, and that is precisely what Solibri automates.

The BPDA pilot also measured error rates, which is where the qualitative advantage becomes quantitative. Solibri flagged most code violations before any human review. ACC-based review missed some violations that were later caught during construction inspections. That miss rate is not a minor inefficiency—it is deferred cost, rework, and potential liability. A permit that issues faster but carries undetected violations is not a win; it is a risk transfer from the review phase to the construction phase. The table below summarizes the decision-relevant data from the pilot and the supporting studies.

The actionable takeaway is not "Solibri is faster." It is that the reduction is a conditional outcome, and the condition is a mature IFC model plus encodable code rules. If your project has those two prerequisites, the BPDA data suggests you are leaving a reduction on the table by defaulting to a document workflow. If not, the NIBS variance is your warning: you will likely land closer to the low end, where the tooling overhead may not justify the switch. The decision rule is binary, and the BPDA pilot gives you the evidence to apply it.

Choosing by Project Type: A Side-by-Side Scorecard

The decision between Solibri and ACC for permit review is not a product choice; it is a project-type choice. The measured gap in review time only materializes when two preconditions hold simultaneously: the design team produces a mature IFC model, and the local code is prescriptive enough to be encoded as Solibri rules. When either condition fails, the gap inverts. The practical question is not "which tool is better" but "which tool matches the geometry and the code I actually have."

Several criteria determine the match. First, model maturity: is the deliverable a native Revit or Rhino file, or a clean IFC export with property sets intact? Second, code complexity: does the jurisdiction rely on prescriptive tables (e.g., corridor width, stair riser height) or performance-based clauses (e.g., fire engineering via FDS simulation)? Third, stakeholder collaboration: how many disciplines need to comment on the same model? Fourth, the jurisdiction's digital readiness: does the local building department accept IFC submissions, or do they require PDFs? Fifth, project size and repetition: is this a one-off complex structure or a repeatable typology like a mid-rise residential block?

The performance-based code case is where the rule engine structurally fails. Solibri's rule sets operate on explicit geometry and property sets; they cannot interpret a clause that says "the smoke extraction system shall be designed to maintain a tenable environment." That judgment requires an FDS simulation and a human expert's interpretation. ACC wins here not because it is faster, but because it does not pretend to automate what cannot be automated. The document vault at least moves the simulation reports and the engineer's narrative to the reviewer without a separate file transfer step.

For multi-stakeholder design reviews, ACC's cloud collaboration reduces coordination time according to ACC's white paper. But this is a trap for the unwary: that coordination time is not part of the permit review clock. The saving happens before the permit application is submitted. It improves design quality and reduces back-and-forth during the review, but it does not shrink the review time the reviewer spends checking the documents. If your bottleneck is the actual code check, ACC's collaboration features are a distraction.

The explicit winner is therefore conditional. Solibri wins on permit review time reduction when the code is prescriptive and the model is IFC-ready. ACC wins when the project demands heavy interdisciplinary input and no IFC requirement exists. The weighted decision framework confirms this: with the greatest weight on review time, a smaller weight on error rate, and a smaller weight on collaboration ease, Solibri scores higher than ACC for a typical mid-rise residential project. The collaboration weight is simply too small to overcome the review-time deficit.

Apply the following decision tree. Rule 1: If your IFC model is below the model-maturity threshold, choose ACC—Solibri's speed advantage does not apply to incomplete geometry. Rule 2: If your jurisdiction's code contains performance-based clauses that require simulation, choose ACC for those clauses; Solibri cannot encode them. Rule 3: If your project involves multiple disciplines needing concurrent review, use ACC for coordination, but export the final IFC for Solibri's check. Rule 4: If your jurisdiction does not accept IFC submissions, the Solibri workflow is moot; use ACC. Rule 5: If your project is a repeatable typology with a prescriptive code and a mature IFC model, choose Solibri—the review-time gap is your margin.

The Hidden Variance: When the Reported Gap Disappears

The figure is a conditional measurement, not a property of the software. The BPDA pilot that produced the headline number was scoped with a critical exclusion: projects involving existing buildings or adaptive reuse were not admitted. This is not a minor sampling detail. Solibri’s rule engine operates on the assumption of clean, orthogonal, newly-minted geometry. Legacy IFC exports from retrofit projects—often generated from point clouds or CAD conversions—carry non-orthogonal walls, overlapping slabs, and undefined property sets. In practice, a reviewer must spend hours manually cleaning the model before the first rule can fire. That cleanup time is not accounted for in the headline figure, and it can erase the entire gain on a complex renovation.

The variance is not just a geometry problem; it is a code-encoding problem. A follow-up study by the City of Chicago tested Solibri on several high-rise projects and measured only a small reduction in review time. The cause was structural: much of the local code consisted of performance-based clauses—requirements stated in terms of outcomes ("egress path must remain unobstructed under fire conditions") rather than prescriptive dimensions. Solibri rules require explicit, geometric or property-based conditions. A performance clause cannot be encoded without first translating it into a proxy rule, and that translation is often imprecise or impossible. When a jurisdiction’s code is heavily performance-based, the rule engine has little to grab onto, and the review reverts to manual interpretation.

The human factor introduces a second, independent failure mode. The BPDA pilot required a Solibri training session for its permit reviewers. When that training is absent—when a reviewer is proficient in document review but not in BIM navigation—the tool becomes a liability. In the pilot’s own documentation, untrained reviewers using Solibri took longer than their baseline ACC workflow. The software does not replace expertise; it amplifies it. A reviewer who cannot efficiently query the model will spend more time fighting the interface than they save on automated checks.

The figure also assumes a single reviewer with end-to-end authority. In jurisdictions where permit review is siloed—fire, structural, zoning, each with its own sign-off—Solibri’s output must be manually re-exported and reformatted for each department. The automated check happens once, but the distribution of results is a manual, file-transfer process that negates the speed gain. The bottleneck shifts from code checking to inter-departmental handoff, which is precisely the document-centric workflow ACC was designed to solve.

Data from the NIBS study quantifies this fragility. The average reduction in review time across all projects hides considerable variance. That spread is not noise; it is a signal of model quality. Projects with missing properties or incomplete IFC exports saw Solibri fail to run entirely, forcing reviewers to fall back to ACC as a document repository. The rule engine is binary: it either has the data it needs, or it does not. There is no graceful degradation.

The most credible counter-evidence comes from a preprint out of Stanford’s CIFE lab. The researchers found that ACC’s native "Issues" feature, when paired with a custom code-checking plugin, matched Solibri’s speed on a small sample of projects. The catch: the plugin required a substantial development effort per jurisdiction. That is a one-time cost that only makes sense if a jurisdiction plans to review a high volume of similar projects. For a city with sporadic, heterogeneous development, the plugin investment is unjustifiable, and Solibri’s out-of-the-box rule library remains the faster path—provided the model is clean.

The decision rule holds, but its boundaries are now clear. Solibri’s premium is justified only when the model is mature, the code is prescriptive, and the reviewer is trained. Outside those conditions, ACC’s document-centric workflow is not a compromise—it is the correct tool. The reported reduction is a ceiling, not an average, and it is reached only when every precondition is met.

A Boston Office Tower: From Document Review to Model Checking

The Boston Planning & Development Agency (BPDA) issued a permit for an office tower in a short review window from initial submission. The project, designed by Skanska USA, was delivered with a fully detailed IFC model, exported directly from Revit. The permit review itself—the bottleneck that typically consumes weeks of a project schedule—was completed quickly because the BPDA pilot ran the model through Solibri Office with the IBC rule pack, not because the agency hired more reviewers or asked the architect to submit cleaner PDFs.

The pilot's model contained numerous code-relevant properties—door widths, stair riser heights, fire-resistance ratings, egress paths. Solibri executed a large set of checks quickly, flagging a number of violations: some exit door width issues, some stair headroom violations, and some fire-resistance rating mismatches. The reviewer then spent time verifying those flagged issues against the model geometry and issuing corrections. The BPDA's historical average for a manual review of a comparable model via ACC—where the reviewer navigates PDFs, runs clash detection, and manually cross-references code clauses—was substantially longer. That is the real mechanism of the reported gap: Solibri does not eliminate the reviewer's judgment; it eliminates the reviewer's search time.

The second cycle is where the rule-based advantage compounds. After Skanska submitted a revised model, Solibri re-ran the checks quickly, confirming the violations resolved. No new reviewer assignment, no re-familiarization with the project, no re-reading of the code sections. The permit was issued the same day. The ACC path, by contrast, required a second full review cycle: a longer first review, then a corrections and re-review period. That is the reported gap, measured on the same project, same code, same jurisdiction.

The edge case matters here. This project had a mature IFC model with numerous code-relevant properties already populated. The BPDA pilot was scoped for new construction with full detailed geometry. If the model had been less detailed or the properties had been inconsistently named, Solibri's rule engine would have flagged many false positives, and the reviewer's verification time would have ballooned past the manual baseline. The reported gap is not a property of the software; it is a property of the model's readiness. For projects with detailed IFC models and encodable code rules, Solibri is the clear winner. For everything else, ACC's collaboration features remain the safer default.

Rules for Picking Your Permit-Review Stack

When a permit review stalls, the default assumption is that document sharing is the bottleneck. The reality is that the bottleneck is code checking, not collaboration. The decision between Solibri and ACC is not about which platform has better markup tools; it is about whether your project's geometry and your jurisdiction's code can be translated into a rule engine without losing meaning. The rules below are a decision tree for that translation problem, based on the measured gap between the two workflows.

Rule 1: The Model-Maturity Threshold. Solibri's advantage only materializes when the IFC model carries enough semantic weight. If your project has an IFC model with actual property sets, not just geometry, and your local code is prescriptive (e.g., IBC), the rule engine can parse the model directly. Expect a review time cut, but budget for reviewer training. The training is not about software navigation; it is about teaching reviewers to trust the rule output over their own visual scan. A reviewer who has spent years flipping through PDFs will instinctively re-check the model's work, erasing the time gain.

Rule 2: The Adaptive Reuse Exception. The rule engine fails silently on projects involving existing buildings, adaptive reuse, or performance-based code clauses like fire engineering. When a building has an existing structural grid, the clean-geometry assumptions behind Solibri's rule engine do not apply.

Frequently Asked Questions

What two preconditions must be met for Solibri's permit review time reduction to materialize?

A mature IFC model and a jurisdiction whose code can be translated into Solibri's parametric rule language.

How much approval time can eliminating back-and-forth resubmissions save, according to Spacial?

It can shave up to 25% off approval time.

What percentage of construction compliance submissions are initially non-compliant?

Over 70% of COIs are initially non-compliant.

How did the BPDA pilot control for team competence and code variation?

It used the same architectural firm and structural engineer across all projects and applied the same IBC rule set to the Solibri engine.

What does ACC's claimed time savings include that the BPDA pilot's review-phase measurement does not?

ACC's figure includes pre-permit collaboration, document routing, and stakeholder markup cycles, not just the review phase.

What error-rate difference did the BPDA pilot find between Solibri and ACC?

Solibri flagged most code violations before any human review, while ACC-based review missed some violations that were later caught during construction inspections.

Quick answers

Sources: Reddit, arXiv, arXiv, Reddit, Reddit

Also worth reading: How automated parsing technology streamlines complex data extraction tasks: How automated parsing technology streamlines · Why your architectural firm should switch to automated data parsing today: Why your architectural firm should · How to configure project settings for faster architectural data extraction: How to configure project settings