---
hide:
  - navigation
  - toc
---

# Why Vizro

In the context of comparison with other visualization packages or business intelligence tools, Vizro combines benefits of the speed and user-friendliness of low-code visual analytics tools with the flexibility and power of high-code tools - whilst providing inbuilt visual design, application architecture and coding standardization which also facilitates scaling and reusability.

The simple and largely declarative configuration language follows a “grammar of dashboards” which makes the creation of complex dashboards more intuitive. This leverages modular components, empowering users to rapidly self-serve the assembly of customized dashboards with inbuilt visual styling in minutes, and reduces the amount of “glue code” required, whilst still retaining the ability to enhance functionality almost infinitely through customization and extensions, with standardization increasing the consistency across outputs.

<figure markdown>
  ![Image title](https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/code_dashboard.png)
  <figcaption>Example of how Vizro's configuration language translates into an app</figcaption>
</figure>

Using configuration rather than a GUI to define the output facilitates collaboration during the creation process, and increases reusability and scalability in a Python setting.

The largely tech-agnostic configuration driven assembly enables utilizing a range of tools, and an inbuilt validation layer provides meaningful feedback to users about configuration choices, thereby increasing flexibility and ease of use.

## Python packages and business intelligence (BI) tools

There are a number of Python packages and BI tools which provide support for visualization applications (such as Streamlit, Plotly/Dash, Tableau and PowerBI).

Vizro is intended to support several niches between the benefits provided by those tools, rather than being in direct comparison with any single tool. Therefore, direct comparisons are often only partially suitable, given the many features offered across this landscape.

However, in general, there are several areas of functionality where Vizro can be particularly useful, e.g., in providing a simple configuration to speed up the assembly of components, leveraging inbuilt visual design, application architecture, and coding standards,
along with the ability to scale easily across multiple developers and implementations:

| Functionality                                                                                                                                                                                                                                                                                                                                                 | Benefits                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | In context of Python packages                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | In context of BI tools                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :  | :  | :  |
| **Assembly system** <ul><li>Configuration-driven assembly system of Vizro automatically builds user-friendly, higher-level dashboard concepts (e.g. a filter) from low-level individual components (e.g. a dropdown component plus a filtering function).</li></ul>                                                                                           | <ul><li>Removes the need for users to learn how to write the “glue code” which combines lower-level components.</li><li>Removes the time taken to write, test and optimize the “glue code” which combines lower-level components.</li><li>Reduces what can be 1000s of lines of code down to dozens of lines of configuration.</li></ul>                                                                                                                                                                                                                                                                                                                                                                            | Many Python packages still require a moderate understanding of the coding required to assemble higher-level dashboard concepts, which necessitates the creation of “glue code” to combine lower-level components. <br/><br/> Vizro primarily provides a configuration to simplify that assembly of components offered by existing packages (currently leveraging Plotly/Dash), and so occupies a slightly different niche from libraries offering primarily the lower-level components themselves. It also removes the requirement from users to implement certain code standards for the assembled code themselves, and therefore saves time on often time consuming things such as writing unit tests and ensuring linting coverage. | Many BI tools incorporate the assembly of higher-level concepts automatically from GUI (drop-and-drag) interfaces, and occupy a slightly different niche to the configuration driven assembly provided by Vizro.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| **Inbuilt visual design decisions** <ul><li>UX decisions such as placement of filters and orientation of charts in relation to other components on the screen.</li><li>Visual design decisions such as chart formatting and spacing between components.</li><li>Colors including text, backgrounds and chart contents.</li></ul>                              | <ul><li>Ensures visual consistency within applications, and across applications built by the same user.</li><li>Speeds up development by removing the need to spend time on visual design decisions.</li><li>Removes the need for advanced expertise in visual design.</li><li>Ensures basic color accessibility for most likely color combinations.</li></ul>                                                                                                                                                                                                                                                                                                                                                      | Many Python packages provide inbuilt color choices, and visual design choices for certain components. <br/><br/> Vizro applies that to a wide range of component combinations and complex user flows, offering a wholistic and comprehensive approach to automatically enable beautiful visual design best practices, whilst allowing customization and flexibility.                                                                                                                                                                                                                                                                                                                                                                   | Many BI tools provide inbuilt color choices and visual design choices for certain components. <br/><br/> Vizro provides inbuilt visual design for components in addition to the ability to customize them in a flexible way where needed (for example through CSS), and provides automatic arrangement of components on the screen.                                                                                                                                                                                                                                                                                                                                |
| **Inbuilt application architecture decisions** <ul><li>The architectural decisions required to connect components in advanced ways - such as combining connecting filters to charts with multi-screen navigation to allow drill-throughs between screens.</li></ul>                                                                                           | <ul><li>Ensures structural consistency within applications, and across applications built by the same user.</li><li>Speeds up development by removing the need to spend time on architectural decisions or development.</li><li>Removes need for advanced expertise in application architecture.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                          | Many Python packages provide inbuilt application architecture choices for certain functionalities. <br/><br/> Vizro applies that to a wide range of component combinations and complex user flows, offering a wholistic and comprehensive approach to the entire application architecture, whilst allowing customization and flexibility where relevant.                                                                                                                                                                                                                                                                                                                                                                               | Many BI tools apply proprietary application architecture by default. <br/><br/> Vizro enables the user to view and understand the application architecture by directly viewing the code.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| **Declarative configuration, in multiple formats** <ul><li>Configuration is declarative and can be written in Python or a configuration language such as YAML, JSON and TOML.</li></ul>                                                                                                                                                                       | <ul><li>The range of formats enables flexibility in implementations (and can be extended in future).</li><li> Formats such as YAML support programmatic construction of dashboards (for example being dynamically generated from a Kedro pipeline).</li><li>The focus on editing configuration directly, rather than via GUI or drop-and-drag interfaces, allows for ease of collaboration.</li></ul>                                                                                                                                                                                                                                                                                                               | Many Python packages provide a mostly declarative configuration, with limited ability to leverage multiple formats such as Pydantic models and JSON. <br/><br/> Vizro simplifies this approach, and facilitates the extension of the assembly system to enable integration with other tools such as Kedro to programmatically and dynamically generate the relevant dashboard configurations in a streamlined way.                                                                                                                                                                                                                                                                                                                     | Many BI tools solely use a GUI and/or drag-and-drop interface for defining dashboards, and leverage proprietary configuration formats. <br/><br/> Vizro enables the user to view and understand the configuration by viewing it directly, in addition to being able to edit it directly.                                                                                                                                                                                                                                                                                                                                                                           |
| **Mostly tech agnostic “grammar of dashboards”** <ul><li>The configuration follows a “grammar of dashboards” which is mostly generic and tech agnostic (rather than being specific to any Python package or coding language).</li></ul>                                                                                                                       | <ul><li>Enables a more intuitive understanding of how to write the configuration.</li><li>Enables the configuration to apply to other Python packages or other coding languages in future. (NB: this would require an adjustment to the underlying assembly core code).</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                   | Many Python packages provide an effective “grammar of charts” and Python specific declaration. <br/><br/> Vizro provides a “grammar of dashboards” with declaration which is largely tech agnostic and can be extended to non-Python languages.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Many BI tools utilize an implicit internal “grammar of dashboards” which is specific to the proprietary language(s) on with which they are built. <br/><br/> Vizro provides an explicit configuration grammar and allows users to leverage a mostly tech agnostic approach (which can be extended in future).                                                                                                                                                                                                                                                                                                                                                      |
| **Inbuilt validation** <ul><li>The ability to leverage Pydantic models automatically provides meaningful feedback to users about configuration choices.</li></ul>                                                                                                                                                                                             | <ul><li>Increases ease of use by guiding users, providing early validation and clear feedback throughout the configuration process.</li><li>This validation feedback can also be utilized by processes which construct the configuration programmatically, such as via a Kedro pipeline.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                  | Many Python packages provide individual components or non-Pydantic based models. <br/><br/> Vizro provides the advantages of Pydantic based models for many elements of the configuration process, which leverages the validation and guidance inherent in that process to facilitate implementation by users.                                                                                                                                                                                                                                                                                                                                                                                                                         | Many BI tools have inbuilt guideline systems to ensure components are combined in a valid way, and provide feedback to the manual user to help guide through that process. <br/><br/> Vizro utilizes a flexible system which can be extended to provide feedback to programmatic generation of configuration.                                                                                                                                                                                                                                                                                                                                                      |
| **Modularity** <ul><li>The standardization applied by Vizro (in terms of visual design, application architecture and coding standards) makes it possible to reuse configuration, charts, components and extensions such as custom actions, between implementations.</li></ul>                                                                                 | <ul><li>Speeds up development by allowing reuse of existing implementations.</li><li>Facilitates collaboration between users by allowing knowledge to be encoded in modular ways.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Many Python packages provide modularity of components such as charts and controls. <br/><br/> Vizro supports modularity of groups of components (such as their implementation together as a dashboard screen), which can be easily transferred between implementations as configuration.                                                                                                                                                                                                                                                                                                                                                                                                                                               | Many BI tools provide extensions and plugins which support modularity of visualizations. <br/><br/> Vizro supports modularity of groups of components (such as their implementation together as a dashboard screen), which can be easily transferred between implementations as configuration.                                                                                                                                                                                                                                                                                                                                                                     |
| **Flexibility** <ul><li>The ability to utilize the low-code approach of configuration with the high-code approach of custom functions provides flexibility in implementation for both less technical and more technical users.</li></ul>                                                                                                                      | <ul><li>The low-code configuration driven approach enables all users to create fairly flexible dashboards easily.</li><li>The high-code approach of using custom functions in a structured way provides more technical users with flexibility to extend functionality almost infinitely.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                  | Many Python packages provide some low-code and/or high-code approaches, which offer varying degrees of flexibility. <br/><br/> Vizro provides a wholistic combination of low-code and high-code approaches which support less technical and more technical users individually while allowing them much flexibility in implementation according to their technical level.                                                                                                                                                                                                                                                                                                                                                               | Many BI tools offer a no-code (or at least low-code) approach to creating charts and dashboards, along with varying forms of plugins to increase flexibility. <br/><br/> Vizro unlocks Python custom functions to be able to power this user driven flexibility in a technically advanced way, with a high degree of control and visibility over the code, whilst also supporting less technical users through low-code configuration.                                                                                                                                                                                                                             |
| **Scaling** <ul><li>The consistency in visual design, application architecture and code standards, combined with the ease of collaboration between Python developers, allows scaling within and between projects by facilitating reuse, extension and programmatic updates of configurations.</li></ul>                                                       | <ul><li>Sections of configuration can be reused and tailored easily, allowing implementations to scale across or between projects.</li><li>New joiners to a team can get up to speed quickly, allowing teams to scale in size.</li><li>Other teams can inherit configurations easily, allowing implementations to scale between teams.</li><li>Updates can be propagated to configurations from a central location, allowing adjustments and updates to scale easily across large implementations.</li><li>Inbuilt visual design decisions provide visual consistency.</li><li>Leveraging collaborative coding mechanisms such as Git enables almost any number of developers to collaborate effectively.</li></ul> | Many Python packages benefit from the ability to propagate updates programmatically, while applying that to “glue code”. <br/><br/> Vizro makes it easy to scale by replicating the relatively small amount of configuration in 1 file between usages, rather than replicating a large amount of code across many files between usages. <br/><br/> Updating configuration programmatically from a central location is often easier than updating code. When sharing between users, it can be easier to inherit and understand configuration than the underlying code. The visual consistency makes it easier to scale within or between projects while maintaining visual coherence.                                                   | Many BI tools allow scaling through GUI drag-and-drop interfaces (having some functionality for duplication or propagating changes) for single users. <br/><br/> Vizro makes it easy to leverage tools such as Git to enable almost any number of users to collaborate effectively, therefore allowing the number of developers on a single project to scale easily. <br/><br/> Since updates can be propagated programmatically easily from a central location, it allows scaling across almost any number of related implementations which can be kept up to date and aligned without the need to manually adjust each implementation when updates are required. |
| **Python first** <ul><li>Leveraging Pydantic and Plotly/Dash provides a Python first approach (whilst making use of a mostly tech agnostic configuration system).</li><li>(Since Plotly/Dash leverage React components, and allow them to be used as components, then JavaScript can also be used in a form that is effectively wrapped in Python).</li></ul> | <ul><li>This empowers a wider group of practitioners that are already close to data analytics, since they are more likely to have existing skills in Python than JavaScript.</li><li>This provides the advantage of leveraging existing Python work spaces such as notebooks and IDEs.</li><li>Facilitates multi-developer collaboration via tools such as Git.</li></ul>                                                                                                                                                                                                                                                                                                                                           | Python packages are already Python focused. <br/><br/> Vizro is no different in this respect. By leveraging Plotly/Dash, Vizro is also able to benefit from the power and flexibility offered by JavaScript via React, whilst still presenting a format that is Python first to the user (by making use of the ability offered by Dash to effectively wrap those components into Python).                                                                                                                                                                                                                                                                                                                                              | Many BI tools do not provide direct or full integration with Python. <br/><br/> Vizro provides a Python first approach which leverages the power and flexibility of Python, and the open source community supporting that wide ranging functionality.                                                                                                                                                                                                                                                                                                                                                                                                              |
| **Open source** <ul><li>The use of an open source license, and the reliance on open source packages.</li><li>The provision of ongoing development and maintenance.</li></ul>                                                                                                                                                                                  | <ul><li>There is no license fee required to utilize Vizro.</li><li>Ongoing development and maintenance increases the long term usability of the Vizro package, and viability of implementations.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Many Python packages also use an open source license, and provide ongoing development and maintenance. <br/><br/> Vizro is no different in this respect.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Many BI tools follow a license fee model and/or charge for ongoing development and maintenance. <br/><br/> Vizro requires no license fee, and provides ongoing development and support, which helps to remove some barriers to usage.                                                                                                                                                                                                                                                                                                                                                                                                                              |

## Cases where alternatives to Vizro are potentially more suitable

There are a number of cases where alternatives to Vizro may be more suitable, including where:

- BI tools are already in use, and/or Python developers are not prevalent

- Development teams already contain designers and JavaScript (or equivalent) engineers able and willing to build bespoke applications (though Vizro can sometimes still be used effectively to rapidly prototype potential solutions)

- Python developers are already comfortable leveraging other Python packages without the desire to use an assembly system, or do not require inbuilt visual design, application architecture or coding standards, and/or the ability to scale easily across multiple implementations or users
