BIM View: Stop Reacting and Start Responding—Proactive Model Management


BIM is a process. Understanding the process and managing it accordingly are key to successful BIM implementation. But how do you measure the development of a Building Information Model? Do you have methods in place to understand when potential issues on your models may occur? The best way to accomplish this is through diagnostic tools that alert users when certain predefined rules are broken, or limits are exceeded.

In this article, we're presenting the lessons we learned through the development of the ‘BIM View’ tool – a macro-based model health check solution, combined with a web-based dashboard, to visualize the quality and performance of all our Revit models. Learn what worked and what did not and why we replaced Dynamo with a macro-based solution, and Power BI with a combination of Vue.js and Data Driven Documents (D3.js), gathering data directly from all our active projects and pushing it into a web-based dashboard to proactively manage all our models.

Stop Reacting

One of the things that occurs in many offices is that, after training, everyone is expected to be an expert at using Revit. But it takes time for new Revit users to get comfortable with the program and the new workflows, and to build up a high level of user knowledge.

New Revit users are usually being asked to learn the software as they're working on a project. Even if they come prepared with basic training, they will quickly find that not everything is going to work like it did in their training sessions, which can lead to frustration!

Quite often, new Revit users not only have to educate themselves online (webinars, e-learning, user forums, etc.) but also find themselves without the support they need to be able to review what they couldn’t do and everything else that caused frustration. Revit’s inability to provide user-friendly feedback isn’t making it easier for them.

Five phases of Revit.

We realized that it was time to develop a tool for our project leaders and BIM managers that could be used not just to monitor the project status and ‘health’ of individual models, but would also allow them to identify critical areas before they turn into problems – a tool that would allow them to proactively manage a project.

Start Responding

When we started to develop the ‘BIM View’ tool, we followed a five-step strategy, detailed below.

Model health check process.


Defining KPIs

A Key Performance Indicator (KPI) is a quantifiable metric that reflects how well a user, project team, or office is achieving its stated goals. For example, if one of your goals is to keep the amount of warnings within your models below a total of 400, you could use a KPI to target the number of warnings that remain unsolved. This will measure the team’s progress toward your goals.

Key Performance Indicators.

Used well, KPIs support your goals and strategy. They allow you to focus on what matters most, and to monitor your progress. At the beginning, we choose KPIs that were directly linked to the model’s health to measure how well our models performed against our key goals.


A way to evaluate the relevance of your KPI is to use the SMARTER (Specific, Measurable, Achievable, Relevant, Time-bound, Evaluate, Re-evaluate) framework:

  • Specific: Be clear about what each KPI will measure, and why it is important

  • Measurable: Your KPI must be measurable to a defined standard

  • Achievable: Your models must be able to report on the KPI

  • Relevant: Your KPI must measure something that matters and improves performance

  • Time-bound: The target must be achievable within an agreed time frame

  • Evaluate: Continuously evaluate your KPI to improve the overall process

  • Re-evaluate: Continuously reevaluate your KPI to optimize the overall process


Once we were satisfied that we had meaningful KPIs to measure the health of our models, we started to look at the infrastructure. The infrastructure can include various pieces of software and is an upfront investment that will allow you to collect data from individual models. We reviewed multiple solutions before we were able to find the one that was suitable for our workflow

Revit > Microsoft Excel

When we started, the auditing process for models included Excel spreadsheets that were manually filled with data – a workflow that did not meet our requirements:

  • Con: Data input 100% manually

  • Con: Needs to be scheduled

  • Con: Time consuming

Revit > Dynamo > Microsoft Excel

We improved this workflow by developing and using a Dynamo graph that partly automated the data input – an improvement but it did not meet our requirements:

  • Pro: Data input partly automated

  • Con: Does not start automatically

  • Con: Dynamo version control needed

  • Con: Warnings via HTML (Revit 2017)

Revit > Dynamo > Dynamo Player

In the next step, we moved away from Excel spreadsheets and developed a ‘model health check family’ that was automatically filled with the data, using the Dynamo player – a massive improvement but it did not meet our requirements:

  • Pro: Warnings directly available

  • Pro: Data input 100% automated

  • Con: Does not start automatically

  • Con: Dynamo version control needed

  • Con: Graph takes 1.5 minutes / model

Revit > Macro Manager > MySQL

Finally, we found a solution that met our requirements by using a macro in combination with MySQL. This solution allowed us to fully automate our infrastructure:

  • Pro: Starts automatically

  • Pro: Data input 100% automated

Collecting Data

After the infrastructure was implemented, we were able to start the data collection for each KPI within our models. But first, we had to define the data collection frequency. Therefore, we looked at the data we wanted to be collected continuously while others could be collected on an hourly, daily, or monthly basis. We decided that we wanted the macro to run every four hours, minimizing the impact on the users experience while working with Revit. Also we run this process when the synchronization is completed to make sure we have the latest data. The code below breaks down the different steps involved in the macros.

1. Register event when a Revit user opens, synchronizes or prints the local model;

2. Extract the data required for the audit and create a timestamp to measure time taken during opening, synchronizing or printing;

3. Send the data to the auditing web service. The PHP based web server records the data in the MySQL database;

4. Find the ‘Model Health Check’ family in the model;

5. Update the ‘Model Health Check’ family with new acquired data.

Macro process overview.

Database Schema

The database schema is actually pretty simple. We store the latitude and longitude of offices and projects to be able to display them on a map. All the audit data can be stored in a large table or grouped in smaller tables.

Database schema.

We currently use a MySQL database and we use views to limit the data we pass to the web viewer to have a more responsive interface. For example, we display only the projects that have been active in the last two weeks, making sure that the data we see is current. So we create a view called ‘recent_projects’ that limits the projects we want to see as follows:

FROM project
INNER JOIN project_file ON = project_file.project_id
INNER JOIN audit_activity ON = audit_activity.project_file_id WHERE (audit_activity.date_created > DATE_SUB(now(), INTERVAL 14 DAY))

Visualizing Data

You can significantly decrease the time it takes to compare metrics by compiling them into one place with an intuitive, visually-appealing format. Dashboards can combine the data that has been extracted from multiple models and communicate this information to the entire team, visualizing the performance of their individual models. When designed correctly, dashboards provide an extraordinary level of accessibility and efficiency. This greatly improves the decision-making process, by providing you and your team with the right data to make an informed decision.

Revit – Project Landing Page

There are different approaches to and opinions on what a landing page should include. However, having a ‘Model Health Check’ family embedded has significantly increased the visibility of our KPIs and their impact on model performance:

  • Pro: Starting view (high visibility)

  • Pro: Data input 100% automated

  • Pro: Updated every four hours

  • Con: Only accessible in Revit

  • Con: Snapshot of the model state (no history)

  • Con: Doesn’t allow comparability

BIM View model health check family.

Power BI – Dashboard

Microsoft Power BI is basically Excel pivot tables with Excel’s data visualization tools taken to the next level. Its user interface is very bulky and depending on the device and browser that we used, it had a negative impact on the visibility and usability of our dashboard:

  • Pro: Transforms data into rich visuals

  • Pro: Data input 100% automated

  • Pro: Accessible to everyone

  • Pro: Allows comparability

  • Con: License costs (maintenance)

  • Con: Compatibility issues (devices)

  • Con: Needs training and support

BIM View – Power BI Dashboard.


Vue.js – Model-View-Viewmodel

Vue.js is an open-source JavaScript framework for building user interfaces and single-page applications. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable, which was perfect for us in combination with D3.js:

  • Pro: Easy to pick up

  • Pro: Reactive

  • Pro: Integrates with other libraries

The web page is split into as many components as needed:

Vue.js – Example of components layout (left) and website (right).


Each component has its own HTML, Javascript, and CSS. This makes maintenance a lot easier as the files are a lot smaller and can be reused as needed. The local CSS in one component doesn’t interfere with the CSS in another component. Below is an example of a Vue.js component structure:

Vue.js – Component structure.

Vue.js is reactive which means that if the value of the variable “project” changes, then the displayed value will automatically change as well. For example, if you use a filter based on a country, then all the graphs and texts will automatically be redisplayed when the country changes. It makes the development very efficient and the web interface dynamic.

Vue.js – Inspector.

Data can also be stored in a global store that all the components can access. An add-in can be installed in Google Chrome to access / modify all the data while running in development mode, which makes development a lot easier, as you can also track events.

D3.js – Data-Driven Documents

D3.js is a JavaScript library for manipulating documents based on data. It helps users to produce dynamic, interactive data visualizations in web browsers. Combined with Vue.js, it was the solution we were looking for to produce our BIM View dashboard:

  • Pro: Transforms data into rich visuals

  • Pro: Flexible and easy to understand

  • Pro: No license costs

  • Pro: Data input 100% automated

  • Pro: Accessible to everyone

  • Pro: Allows comparability

  • Pro: Vector graphics

  • Pro: Graphics can be animated

D3.js – Data-driven documents.

We looked at the graphs in this gallery and tried to figure out which ones could help us achieve the best visual experience:

1. Create an SVG element in HTML;
2. Load Data or subscribe to an event when the data changes;
3. Set up XY axes;
4. Iterate over data to build SVG Graphical Elements.

Vue.js – Inspector.


The D3 library is now split into individual nodes, which means you don’t need to load the entire library, just use the nodes you need inside each Vue component.


In the final step, we reviewed the data that was collected on a given problem and its rating system. Where needed, we re-evaluated KPIs to optimize the overall model health check process. Once this evaluation was completed, we deployed the ‘BIM View’ tool for the Australian region. Now, we are in the process of deploying it on a global scale across HDR in multiple languages.

BIM View – Dashboard home.


Proactive Model Management

  • Projects with dedicated BIM managers versus without 
  • Usage of approved and non-approved families (Approved Family Parameter)
  • Improving Model Performance (Model Size and File Data)

BIM View – Dashboard projects.


Proactive Support and Training

  • Comparing teams to find our champions (Mixing High and Low Achievers)
  • Providing help before a support request is being launched (Monitoring and Controlling)
  • Allowing users to see the impact of their own actions in real time (Model Rating 0 - 10)

BIM View – Dashboard files.


Lessons Learned

Having an automated model health check tool such as the ‘BIM View’ in place helps us and our BIM managers to proactively manage our models. However, as a team, model health shall always be everyone’s responsibility – a BIM manager alone cannot fix it all.

We also realized how important it is to provide a dashboard that is highly visible – not just to the individual Revit user and their BIM manager but also to our project leaders who can now ‘see’ which positive effect a dedicated BIM manager can have to their project.

Therefore, we encourage our BIM managers always to keep an eye on the model health check metrics, so they know when help is needed before a support request is being handed in by a Revit user. That allows them to proactively manage their models while improving the performance.


Since Mehdi and I started to work on the ‘BIM View’ tool, we have received support, comments, and advice from many professionals in the AEC industry from around the world. Without them, our work would have been harder and therefore, we would like to take this chance to thank them for their input:

  • Mark Schoolman who introduced us to the existing auditing system and its shortcomings;

  • Josh Moore and Justin Benjamin who shared their custom annotation family with us which we used as a prototype to develop our first 'model health check' family;

  • Ron Croke whose ‘Health Check’ Dynamo graph helped us to develop our own graph;

  • James Wright who developed the first 'model health check’ family and Dynamo graph;

  • Konrad Sobon whose ‘Web-based Project Management’ presentation gave us new ideas;

  • Dan Chasteen and Nicholas Cameron whose ‘You Can’t Manage What You Don’t Measure’ handout helped us developing our first version of the ‘BIM View’ dashboard;

  • And last but not least, David Austin and Simon Leith for their great IT support.

Knowledge sharing is an important part of what we do in our daily work and events like the Autodesk University also foster that sharing.

Learn more with the full class.

Holger de Groot rejoined HDR in 2017 and brings a wealth of knowledge and experience in BIM and management, project management, and healthcare design to the Design Technology Leadership Team. As national director of BIM for the Australian region, his role is to supervise and guide digital practice leaders at HDR. He is responsible for implementing and advising leadership on the corporate Digital Practice BIM Strategy, interacting with various disciplines and advising on BIM matters at all levels. Holger is not only passionate about the implementation of BIM in the planning process, but he also has a strong link to the construction side of projects, having participated in and managed BIM projects in a variety of roles in Australia, New Zealand, Germany, and the United Kingdom.

As technology innovation specialist and software developer at HDR for more than seven years, Mehdi Blanchard’s role is to assess new technologies and find creative ways to implement them in HDR’s workflows. He also researches, designs and develops custom software solutions for HDR globally to improve the BIM process. Mehdi has worked in the AEC industry for more than 15 years. He holds a postgraduate degree in software engineering from the Mediterranean Institute of Research and Computer Science and Robotics (IMERIR) in Perpignan, France and has also studied computer graphics and 3D animation at the Computer Graphics College of Sydney (now SAE).

Companion Class

BIM (Building Information Modeling) is a process, and understanding the process and managing it accordingly is the key to successful BIM implementation. But how do you measure the development of an intelligent model? Do you have methods in place to understand when the potential for issues on your models occur? The best way to accomplish this is through diagnostic tools that alert users when certain predefined rules are broken or limits are exceeded. In this session, we will present the lessons...

Share Article