How to Set Up Quality Control Checks for BIM Models

Why Quality Control Matters in BIM

Every BIM model is a collection of thousands of elements — walls, doors, columns, ducts, beams — each carrying geometry and data. When any of that data is wrong, the consequences cascade. A misspelled material code causes incorrect quantity takeoffs. A missing fire rating on a door triggers compliance failures during review. An element placed at the wrong elevation creates a clash that is not discovered until steel is being fabricated.

Manual quality control does not scale. A reviewer can open a model and spot obvious visual issues, but checking that every element has the correct classification code, that every space has an area value, or that every structural member has a material assignment requires examining hundreds or thousands of elements. That is a task for automation.

Automated QC catches errors at the point of upload, before they enter the coordination process. Teams that implement systematic quality checks report significantly less rework, faster coordination cycles, and fewer surprises during construction.

Types of Quality Control Checks

Naming Convention Checks

Naming conventions ensure that elements, views, sheets, and worksets follow a consistent pattern. A typical convention might require wall types to follow the format WAL_XX_NNN where XX is a two-letter discipline code and NNN is a numeric identifier.

Naming checks are simple to implement and catch a large category of data quality issues. If an element is named incorrectly, it often means it was not set up according to the project template, which may indicate deeper problems with its properties.

Required Parameter Checks

These checks verify that specific properties are present and non-empty on elements. For example:

• Every IfcDoor must have a FireRating property
• Every IfcSpace must have an Area value greater than zero
• Every structural element must have a Material assignment
• Every element must have a Classification reference

Required parameter checks enforce the information requirements defined in the project BIM Execution Plan (BEP). They ensure that models contain the data needed for downstream processes — cost estimation, energy analysis, facility management.

Geometric Constraint Checks

Geometric checks validate spatial relationships and dimensional properties:

• Elevation checks: Are all elements on a given storey within the expected elevation range?
• Origin checks: Is the model's project base point at the agreed coordinates?
• Overlap checks: Do any elements of the same type occupy the same space?
• Dimension checks: Are wall heights within acceptable ranges? Are column sizes standard?

These checks catch modeling errors that may not be visible when viewing the model but cause problems during coordination or fabrication.

Classification Compliance Checks

Classification systems like Uniclass, OmniClass, or national standards assign codes to building elements. Classification compliance checks verify that:

• Every element has a classification reference
• Classification codes match the expected system (e.g., Uniclass 2015 codes follow the Ss_XX_XX_XX pattern)
• No elements use deprecated or invalid codes

Classification compliance is often a contractual requirement, especially on public sector projects that mandate specific classification systems.

Manual vs Automated QC

Manual Review

Manual review involves a BIM coordinator opening each model submission, visually inspecting it, and checking properties on a sample of elements. This approach works for small projects with infrequent model updates, but has clear limitations:

• Inconsistent coverage: Reviewers check different things each time
• Time-intensive: A thorough manual review can take hours per model
• Not repeatable: The same reviewer may miss different issues on different days
• No audit trail: Unless the reviewer documents every check, there is no record of what was verified

Automated QC Pipelines

Automated pipelines run a predefined set of checks against every model upload. The advantages are significant:

• Consistent: The same checks run every time, on every element
• Fast: A pipeline can check thousands of elements in seconds
• Documented: Every run produces a findings report with element-level detail
• Scalable: Adding a new check takes minutes; it then runs on every future upload

The trade-off is upfront setup time. Someone needs to define the checks, configure the rules, and test them against representative models. This investment pays for itself quickly on any project with more than a handful of model submissions.

Building a QC Pipeline in Viralution

Viralution provides a visual pipeline builder for composing quality control checks. Here is how to set up a pipeline from scratch.

Step 1: Create a New Pipeline

Navigate to the Quality Control section in your project. Click "Create Pipeline" and give it a descriptive name — for example, "Architectural Model Submission Checks" or "Structural Steel QC".

Step 2: Add Check Nodes

The pipeline builder presents a canvas where you drag check nodes into a workflow. Each node represents a specific validation rule. Connect nodes to define the execution order.

Available check types include:

• Naming check: Validate element names against regex patterns
• Parameter check: Verify that required properties exist and have values
• Duplicate check: Find elements with identical geometry or properties
• Origin check: Verify model origin coordinates match project standards
• Empty element check: Find elements with no geometry or zero-area footprints

Step 3: Configure Rules

Each check node has a configuration panel where you define the specific rules. For a naming convention check, you would specify:

check: naming-convention
target: element.type_name
rules:
  - pattern: "^[A-Z]{3}_[A-Z]{2}_\\d{3}$"
    severity: error
    message: "Type name must follow CODE_TY_NNN convention"
  - pattern: "^(?!.*COPY).*$"
    severity: warning
    message: "Type name should not contain COPY"

For a required parameter check:

check: required-parameters
target: element
rules:
  - property: "FireRating"
    applies_to: ["IfcDoor", "IfcWall"]
    severity: error
    message: "Fire rating is required for doors and walls"
  - property: "Material"
    applies_to: ["IfcColumn", "IfcBeam", "IfcMember"]
    severity: error
    message: "Material assignment is required for structural elements"

Step 4: Run Against Models

With the pipeline configured, trigger a run against an uploaded model. The pipeline processes each check node in sequence, collecting findings for every element that violates a rule.

Results appear in a findings panel grouped by severity (error, warning, info). Each finding identifies the specific element, the rule it violated, and a human-readable message explaining the issue.

Step 5: Review and Iterate

Review the findings from your first run. Some findings will be legitimate issues that need fixing in the authoring tool. Others may indicate that your rules are too strict or too lenient.

Iterate on the check configurations until the pipeline produces meaningful, actionable results with minimal false positives. Then set the pipeline as the standard for all model submissions in the project.

Advanced Pipeline Patterns

Template-Based Pipelines

Rather than building every pipeline from scratch, start with a template. Viralution provides pre-built templates for common scenarios:

• General QC: Basic naming, parameter, and origin checks applicable to any discipline
• Architectural: Checks specific to architectural models (room data, finish specifications)
• Structural: Checks for structural models (material grades, connection properties)
• MEP: Checks for mechanical, electrical, and plumbing models (system assignments, flow data)

Clone a template and customize it for your project's specific requirements.

Auto-Trigger on Upload

For maximum coverage, configure your pipeline to run automatically whenever a new model version is uploaded. This ensures that every submission is checked before it enters the coordination process.

Auto-triggered pipelines run in the background. Team members receive a notification when the run completes, with a summary of findings. If critical issues are found, the notification makes this immediately visible.

Multi-Stage Pipelines

For complex projects, chain multiple pipelines. A first-stage pipeline might check basic data quality (naming, required parameters). A second-stage pipeline runs only if the first stage passes, checking more advanced criteria (classification compliance, dimensional constraints).

This staged approach avoids overwhelming modelers with a wall of findings. Fix the basic issues first, then address the advanced requirements.

Severity Thresholds and Gating

Not all findings carry the same weight. A missing fire rating on a fire-rated wall is a critical error that should block model acceptance. A non-standard type name is a warning worth fixing but not a reason to reject a submission. Configure severity levels deliberately: errors for requirements that affect safety, compliance, or downstream data integrity; warnings for best-practice violations that should be corrected but do not block progress; and informational notes for suggestions that improve model quality incrementally.

Some teams configure their pipelines as hard gates — a model with any error-level findings is flagged and cannot proceed to coordination until the issues are resolved. Others use a softer approach where findings are reported but model acceptance is a human decision. The right approach depends on the project's risk profile and the maturity of the modeling teams involved.

Getting Started

The key to successful BIM quality control is starting simple. Define three to five checks that address your most frequent modeling issues. Run them consistently. Review the results. Then gradually add more checks as your team builds confidence in the automated workflow.

Every check you add is one fewer thing a human reviewer needs to catch manually. Over the course of a project, that saves significant time and catches issues that manual review would miss.

Visit our quality control documentation to learn more about available check types and configuration options, or explore the template gallery in your project's QC section.