In the past, many organizations relied on static file reports to make decisions. Typically, several Excel and PowerPoint reports are generated each month.

Management would gather, discuss results, decide, and move to email other systems or meet with their teams to pass these decisions forward.

There are multiple problems with static reports - they are error-prone, allow accidental changes, and quickly become messy. 

An alternative that organizations apply for business-critical systems allows them to make decisions based on the most recent data but also to integrate with other systems directly from the app, so no external communication is needed.

For very small problems and one-offs, we can still use Excel or Google Sheets. However, for long-term successful projects, we will need to scale our decision systems. For many data science teams, this means creating a web application in Shiny, Streamlit, or Dash. These tools allow teams to rapidly build powerful decision support systems, especially when working closely with data. But what if we need to scale even further? What if we need to support hundreds or thousands of users, possibly in multiple regions?

Tired of fighting with spreadsheets? Learn how Shiny can help you ditch the spreadsheets and work smarter.

For business critical systems with a wide user group, it probably makes sense to use a mature combination for scalable applications. This will not only make it easier to deliver great user experience, hence improving the adoption - it will also make infrastructure and maintenance costs lower. 

React and Python might be an answer for you when:

1. You look into building a business-critical system for hundreds or thousands of users.
2. Your team built a successful, extensive system in Shiny, Dash, or Streamlit. Right now, maintenance, scale, and technical debt are getting hard to justify.

‍React and Python are the perfect combination for building scalable, business-critical decision support systems.

Shiny for Python is here, and we’ve got the ultimate guide. Learn how to build interactive web apps with ease.

‍Understanding Modern Dashboards and Decision Support Systems

A decision support system is a software application that helps users make decisions based on data. While the terms "dashboard" and "decision (support) system" are often used interchangeably, we believe they are different. 

While dashboards (think of PowerBI/Tableau) allow users to explore data, decision support systems allow users to immediately make decisions based on data. Business Intelligence allows you to “read” data.

A Decision Support System allows you to “read” and “write” data. This is what makes Shiny so powerful - it allows you to build decision support systems directly in R.

Choosing the right data visualization tool can be tricky. Our blog compares R Shiny, Power BI, and Spotfire to help you find the best solution.

‍At Appsilon, we specialize in building decision systems that fit the needs of our clients. For small to medium-sized projects, we use Shiny as it's the fastest way to build a prototype and validate business assumptions. Shiny also has the benefit of being completely customizable and allows for developing beautiful apps that people are excited about.

However, for larger projects, we recommend considering the React and Python tech stack. This allows us to build fast user interfaces that many business folks expect nowadays. With this stack, applications load quickly, you can interact with it quickly. Load times are quick for tens of thousands of users. With many business users and high business expectations, it’s better to invest upfront and build something that gets adoption and leads to a business change, later, you will save money on maintenance and infrastructure.

‍React is a JavaScript library for building user interfaces, so called front-end library. React's capabilities are demonstrated by its adoption in large-scale applications. Companies like Facebook, Netflix, Airbnb, and many others rely on React to serve millions of users daily, handling complex interactions while maintaining smooth performance.

This enterprise-level adoption showcases React's ability to scale beyond what's typically possible with frameworks like Shiny, Dash, or Streamlit. React is also a great choice for building mobile-friendly applications through React Native. 

Python, on the other hand, is a general-purpose programming language that is widely used in data science. Python is the most popular and fastest-growing language overall providing packages and SDKs for almost everything out there. 

The FastAPI library allows you to build asynchronous APIs in Python that are as fast as they can be and scalable. It's a perfect choice for building the back-end of your business critical decision system.

While Django remains a robust framework with excellent content management capabilities and we actively maintain Django projects, FastAPI's modern async architecture and lighter footprint make it our recommended choice for new dashboard applications to iterate quickly.

Shiny for Python + Generative AI = Smarter Apps. See how to build AI-powered web apps with our step-by-step guide. 

‍The versatility of Python and its active usage in both data science and back-end development makes it the natural choice for this stack, allowing you to seamlessly integrate your modeling and server logic in a single language. 

We’ve also seen use cases of applications starting with Shiny for Python and React and outgrowing Shiny to a different backend server like FastAPI. 

‍What if you need to use R in your decision system? No problem. There are two primary ways to integrate R with React + Python stack.

Our recommendation is to create a separate R API with {plumber} and call it from your Python API. This allows for better separation of concerns, easier maintenance and scalability. Alternatively, you can just use the reticulate package to call R code from Python. 

Want to bridge the gap between R and Python? We explore two must-know packages that make integration easy, read more in our blog.

‍Value Proposition for Business Critical Decision Support Systems

Let's quickly list the benefits of building decision systems with React and Python:

• Scalability
• Performance
• Long term maintainability
• Talent availability

Let's start with scalability. Out of the box, Shiny’s architecture is optimized for interactivity and data analysis rather than massive concurrent users. However, with the right engineering,

Appsilon has built Shiny solutions that support hundreds of concurent users. When scaling beyond this, teams may consider React and Python as Stateless React and Python applications can scale easily to thousands of users and more. 

This is possible because the prime limiting factor is the backend performance. And the FastAPI backend can easily be scaled horizontally, meaning you can increase the capacity of your application by running multiple instances of the API across different servers or containers rather than just relying on a single server with higher resources (called vertical scaling). Unlike Shiny applications, which rely heavily on server-side processing and websockets for every interaction, React applications handle most user interactions directly in the browser.

While Shiny needs to communicate with the server for nearly every user action, React applications only reach out to the server when necessary - typically for data-intensive operations or complex calculations. This architecture makes React applications more responsive and provides a smoother, snappier user experience, as simple interactions like filtering, or sorting happen instantly in the browser. For data-heavy features that require server processing, React can still efficiently communicate with FastAPI using either regular API calls or websockets when real-time updates are needed. The consequence of this is that you can build more complex applications while improving performance, maintainability, or user experience. Why don’t we use it for all the applications if that’s the case?

1. To build in this paradigm you need people with knowledge of Python and/or JavaScript. Note that skills used in Data Science in Python are very different from Web Development Python.
2. Application is more mature, but is harder to build. You need a larger team and more time.

The good news is that with the use of GenAI costs of building go down again. It was never cheaper to build a large, scalable decision support system than today. Both React and FastAPI are very well-documented and have large communities, orders of magnitude larger than Shiny or even Streamlit/Dash. This means that you can find solutions to your problems faster and it will be easier to find a team to maintain the application.

Not sure whether to use R Shiny or Python Dash? We’ve compared both so you can choose the best framework for your project.

Why Enterprise Decision Systems Need React & Python - Beyond Traditional Analytics Tools

Let's go through different scenarios where you might want to step up your analytics game.

Scaling past conventional BI tools

Business intelligence tools like PowerBI, Tableau, or Looker are great for... looking at your data. Especially when it's tabular data. They scale very well in those scenarios.

However, when you want to extend the dashboard with custom functionality, you quickly run into limitations. This functionality might be a custom visualization, a predictive model, unstructured data or a real-time streaming. It can also be taking actions based on the data, like sending an email, correcting or adding data or communicating with an external system. This is where you should consider building a decision system with React and Python, or Shiny.

💡Note that it's possible to embed PowerBI dashboards in your React application.

Looking for an Excel alternative? We break down the differences between Power BI and R Shiny to help you choose the right tool.

‍When to evolve from Shiny for R applications

Shiny is a great tool for building prototypes and small to medium-sized decision systems. It allows for rapid development and is very customizable. However, when you need to scale your application, you might run into performance issues.

Some of them are solvable by optimizing your code. Others are inherent to the Shiny architecture. There's a point where you already know what you want to build and you need to build it in a scalable way. You're fine with your data science teams understanding not the whole application but only the parts they are responsible for (e.g., the model, reports, TLFs) when it brings the load time from 30 seconds to under 1 second. This is where you should consider building a decision system with React and Python.

Scaling Shiny doesn’t have to be complicated. Find out whether RStudio Connect or a custom solution is the best fit for your needs.

‍Limitations of notebook-based dashboards

‍Jupyter notebooks are great for exploratory data analysis and prototyping. However, the moment you want to share insights with someone non-technical, the problems start. If your analysis is done in notebooks, you're probably at the stage where you need to build a decision system. However, most often, you should start with Shiny for Python or R, or Streamlit before investing in a business-critical solution.

Shiny for Python makes web development easier than ever. Dive into our comprehensive guide and start building today.

‍Advantages over standalone Python frameworks

This case is similar to the Shiny one. Shiny, Streamlit, or Dash can take you only so far. When you need to scale your application, you should consider building a decision system with React and Python. The good news is that you can keep a lot of your logic from Shiny or Streamlit. 

The same libraries that were used for data processing and modeling like pandas, numpy, or scikit-learn can be used in your Python API. This is important as it allows for a smooth transition from a prototype to a scalable solution.

Additionally, your data science team can still use the tools they are familiar with. Even if they couldn't develop the whole full-stack application from scratch, data scientists can contribute by extending the exsisting application by creating endpoints on their own.

This means you may not need full-stack engineers for adding smaller features to the application. 

Dashboards that use neither Python nor R ecosystem

It may be surprising, but we see many business cases where there's no need for the data analysis part to be backed-in into the decision system.

In such cases, using Shiny and Streamlit leads to sacrificing performance and scalability. If your use case requires custom features or extra reactivity, full-stack frameworks are an excellent choice for building such applications. If your only task is to display a simple chart or table, you may be better off using BI tools like PowerBI or Tableau. It's easier to unlock the full potential of web applications with technology designed for it.We recommend asking yourself whether you actually need data processing or modeling in your decision system. We’re happy to help find an answer to this question together. 

In House Development vs. Outsourcing React & Python Decision Systems

Building a decision system in React and Python is something different than building a Shiny application. Shiny apps are often built by data scientists that want to share their insights with others.

As discussed earlier, you want to create a React + Python application when Shiny or Streamlit is not enough, when the app is slow, when you need to scale it by a large factor, or when you plan to maintain it for a long time. When you decide to build a decision system with React and Python, you have two primary options.

You can build it in-house or outsource it to a software development company like Appsilon. If you have a team of experienced React and Python developers, you can naturally build it in-house. However, if you don't have such a team, or they are busy with other development you should consider outsourcing it.

This may allow you to get to production quickly, reuse best practices from the market and focus on business impact and adoption. What's important is that you can outsource the development of a decision system with or without keeping the data science part in-house.

Our Machine Learning and Data Science team will be able to take over if needed, but if you prefer to work together work will be naturally streamlined by the API-first approach and Python, a language commonly used by both data scientists and developers. For the parts that require R, we can develop a separate R based {plumber} API that is called from the Python API.

Building an R REST API is easier than you think! Learn how to use Plumber to create and deploy your own API in our latest guide.‍

To Migrate or Not to Migrate - A Rule of Thumb for Decision Systems

Systems migration comes with a lot of risks and costs, it's not something to be taken lightly. However, if your current decision system is slow, unresponsive, or not scalable, it's time to consider migration. The slower the system, the lesser the user's adoption.

‍Try to identify applications that are critical for your business but are not performing well. Dashboards that you want others to use but the adoption is falling, the users are complaining about the speed, or the system is crashing. These are the applications that you should consider migrating.

💡We don't recommend migrating all your applications just because you see that React and Python would be a better fit. Technologies like Shiny, Streamlit, or Dash are great for prototyping and building small to medium-sized applications. If it's not broken, don't fix it.

There are also plenty of ways to make them faster and better without investing into migration - each case requires proper judgment. When you decide to migrate, start with a short pilot project. This will allow you to test the new technology in a controlled environment.

You will also be able to identify potential problems early on. But you may also observe early users and data science teams that are more productive and happier with the new technology!

Even if they can't develop the whole application from scratch, they can still iterate on encapsulated modules, or introduce a new model endpoint.

Technology Stack for New Decision Systems

Starting from scratch has the benefit of choosing the best technology stack for your needs. We gathered a comparison of Shiny/Streamlit and React + Python technology stacks below.

Outside of React & Python - Other Technologies to Consider

While we focus on React and Python here, the majority of principles apply as well to other technologies with separate front-end and back-end.

Front-end

While React remains the most popular front-end library, there are other popular options like Vue.js, Angular, and Svelte.

That said, React boasts the largest community and an extensive array of resources, making it a reliable and practical choice for most teams. If your organization or team already works with a different framework, it's likely the best starting point to align with your existing expertise and infrastructure.

Back-end

For the back-end, we recommend Python and FastAPI in particular.

This is because data scientists are already familiar with Python and often use it for data processing and modeling. Then they can use the same libraries in the back-end to share their insights with others without the need to learn a new language, without the middleman.

In Python, you can also use Django, which excels in building large applications, with CRM-like functionalities, admin panels, etc. But those are not the functionalities you need in a typical decision system.

You prefer to have a fast, lightweight, scalable, and maintainable API, where your data scientists can easily add new endpoints/features. It's possible to use Node.js, Go, Rust, C# or Java for the back-end, but this will make architecture of a decision support system more complex and can further complicate the development and grow the costs.

With Python and FastAPI you keep backend development easier, typically faster and cheaper.

Deployment Strategies for React & Python Decision Systems

Deployment of React & Python-based applications doesn't require any licensing or special infrastructure. You can deploy your application on any cloud provider, on-premises, or in a hybrid environment. The possibilities are endless, starting from one server, through Kubernetes with Docker containers, to serverless. The choice of deployment strategy depends on your needs, the size of the application, the number of users, and the budget. This should be discussed with your Infrastructure or Platform team.What's important is that you can start small and scale as needed, without the need to rewrite the application.

Want to make your Shiny app reproducible and portable? Learn how to use {renv} with Docker in our step-by-step guide.

Case Studies of React & Python Decision Systems

‍Impacting Pharmaceutical Supply Chain: Empowering Planners with Business-Critical Shiny Apps

‍We worked with a global pharmaceutical company facing challenges in their supply chain and analytics processes. Teams struggled with inefficient workflows, disconnected data, and slow decision-making, making it difficult to operate effectively.

Our collaboration began with a Shiny Proof-of-Concept app, which quickly demonstrated value by improving processes and secured stakeholder approval for further development. 

Building on this success, we created a scalable platform using Python and React. This centralized solution brought their data together, automated key workflows, and integrated R Shiny apps to provide actionable insights across departments. The platform now supports over 700 users, driving improved collaboration and faster decision-making.

In addition to the core platform, we delivered over 10 R Shiny apps to solve specific business challenges, introduced a user adoption tracking tool, and supported the client in implementing Posit products to optimize deployment and licensing. These efforts not only addressed immediate issues but also set the foundation for ongoing growth and innovation. This partnership showcases how combining tools like R Shiny, Python, and React can create impactful, scalable solutions that transform business operations and deliver long-term success.

‍Scaling Decision Systems with React and Python for Pharma Supply Chain

‍We partnered with a Fortune 500 pharmaceutical company that was dealing with inefficiencies and errors in their supply chain. Manual processes slowed processes down, mistakes were common, and teams had a hard time staying on the same page. We stepped in and built a cloud-based decision support system with React and Python.

The platform brought all their supply chain data together in one place, automated repetitive tasks, and made it easier for teams to model, visualize, and coordinate their workflows. It fit right into their existing processes and helped them solve problems faster and more effectively.

Other tools we used for this project include TypeScript and NextJS for the frontend, FastAPI for APIs, MS SQL Server for the database, and Azure Cloud for the infrastructure. This shows how React and Python can create scalable, high-performing systems that drive real impact for business-critical operations.

Data problems? We build solutions. Check out our case studies to see how we help Fortune 500 companies tackle their toughest challenges.‍

Future of Decision Systems

We believe that the future of decision systems lies in better understanding the needs of the end users and hence technology. While the past decade was about going from static reports to interactive dashboards, the next will be about picking the right technology stack for the right problem.

No more spending six figures on dashboards for five users. No more waiting 30 seconds for the dashboard to load.

The technology stack matures, the data science teams are more experienced, and the end users are more demanding. We believe that:

• BI tools will continue to be used for tabular data exploration.
• For more complex dashboards of static data we will start using static technologies like Observable Framework or Shinylive as they remove the need for a server.
• For quick prototyping and small to medium-sized applications, technologies like Shiny, Streamlit, and Dash will still be used.

However, for large, production-grade applications with hundreds of users, we will see more and more React and Python applications.

Need a scalable solution for data dashboards? Discover how the Observable Framework makes it easy to build and manage big data visualizations.‍

Conclusion

At Appsilon, we've been building decision support systems and dashboards since 2013, witnessing the shift from static reports to real-time, interactive applications. As technology advances, users now expect fast, secure applications that work seamlessly across devices, including mobile.

Looking to build or scale your decision system? Contact us to see how we can help.