ReliaShiny: A FAIR Application for Reliability Analysis
In ReliaShiny: A 'Shiny' App for Reliability Analysis

knitr::opts_chunk$set(echo = TRUE)

Introduction

Analysis software is a key part of modern reliability engineering. Software helps engineers to model complex systems and analyze large datasets efficiently, abilities that are increasingly important as systems and data become more advanced. Today, most reliability studies rely on specialized software, including both commercial programs and open-source tools. These tools provide many functions, such as statistical modeling and data visualization.

As reliability engineering continues to grow, the need for analysis software that is both powerful and easy for many people to use also increases. Accessible software makes it easier for others to reuse and reproduce an analysis. Reproducibility allows independent verification, while reusability helps others build on previous work. These goals are especially important in reliability engineering, where accurate and dependable analyses directly affect system performance and safety.

Open-source software (OSS) supports these goals by making software open and freely available. OSS not only increases transparency but also fosters collaboration and innovation within the community [1]. Community contributions help identify and fix bugs, improve features, and adapt the software to new use cases. This collaborative approach leads to higher-quality software that better meets the needs of its users.

Recent efforts to improve the quality of OSS have focused on adapting the FAIR principles [2] to software development. Originally created for managing scientific data, the FAIR principles of Findability, Accessibility, Interoperability, and Reusability have also been shown to improve the quality and impact of analysis software [3].

Despite these advances, reliability engineering is still not widely supported. Many reliability tools are proprietary, which limits access for a broader audience. The open-source options that do exist are tied to specific programming languages. While popular packages are available in R [4] and Python [5], they require programming skills that may be a barrier for some users.

This article introduces ReliaShiny, a web-based application that makes reliability analysis easier to use. Built on the Shiny framework [6], ReliaShiny offers an interactive interface for Life Data Analysis (LDA) and Reliability Growth Analysis (RGA), two key tasks in reliability work. The application follows the FAIR principles, aiming to be findable, accessible, interoperable, and reusable for the reliability community.

The following sections explain how ReliaShiny was developed, how it is designed and structured, and how to use it for reliability analysis. The article ends with a discussion of future work and possible improvements.

Development

This project started as a proof of concept for performing Life Data Analysis (LDA) in a web application. The initial goal was to build an easy-to-use interface for popular reliability software packages, making these tools more accessible to a wider audience. Although still under active development, the application has reached a stable stage and is now available for public use. Over time, new features, such as support for Reliability Growth Analysis (RGA), have been added based on user feedback. Moving forward, development will focus on adding more functions to support a broader range of reliability analyses.

The development process was guided by the FAIR principles for research software. These principles shaped important decisions throughout the project, from selecting the core features to designing the user interface. By following FAIR, the goal was to build software that is not only useful but also easy to find, access, integrate, and reuse. This approach helps ensure that the application can effectively meet the needs of its user community.

The following sections describe how the FAIR principles were applied during development.

Findable: The ReliaShiny software and metadata are available in public repositories, including GitHub (https://github.com) and the Comprehensive R Archive Network (CRAN) (https://cran.r-project.org). These repositories provide documentation, installation instructions, user guides, and examples. Because the package is indexed on CRAN, users can easily find it when searching for reliability analysis tools. The software is also assigned a unique identifier through its CRAN package name, making the software easy to reference in other work.
Accessible: ReliaShiny can be easily obtained using standard methods. Users can install the package directly from CRAN using built-in package tools or get the latest development version from GitHub. The software is open, free, and available without restrictions.
Interoperable: The software is interoperable with other tools and workflows commonly used in reliability engineering. ReliaShiny is built in the R programming language, which is popular in data science and engineering. The application can be run on a local computer or on a web server, making it easy to integrate with existing data analysis pipelines. It also supports standard data formats for input and output, allowing seamless data exchange with other software.
Reusable: The software is both usuable and reusable by others. The source code is available under a CC-BY-4.0 license, which provides open access but no warranty. Comprehensive documentation and examples are provided to facilitate understanding and use of the application. Additionally, references to the underlying models and methods are included in the documentation to ensure proper attribution and citation.

While the application adheres to the FAIR principles, some limitations remain. First, ReliaShiny is not a complete reliability analysis tool. The application currently focuses on LDA and RGA, with plans to add more functionality in the future. Second, the web version has limits on data size to maintain performance, which may restrict some analyses. Users who need to work with larger datasets can use the local version without these limits. Finally, although the application is designed to be user-friendly, some basic knowledge of reliability concepts is still needed to use it effectively. To help those getting started in the field, the ReliaLearnR [7], [8] project was created as a companion resource. ReliaLearnR provides learning modules and educational resources to help users understand fundamental reliability concepts and methods.

Design

ReliaShiny is built with the Shiny framework, which is used to create web applications in R. Shiny apps are reactive, meaning their outputs update automatically whenever inputs change. This reactivity allows for highly interactive workflows, making it easy to explore and visualize data quickly. Users can try different inputs and instantly see the results without having to refresh or rerun any code.

A Shiny application has two main parts: the user interface (UI) and the server logic. The UI controls how the app looks and how users interact with it, while the server logic handles the calculations and processes the data.

Shiny offers several layout templates and also allows building interfaces with custom HTML. ReliaShiny uses the shinydashboard [9] package, a Shiny extension made for dashboard-style applications. The user interface is organized into multiple menus for key tasks like data input, model fitting, and visualization. The app also uses the shinyWidgets [10] package to provide better input controls and make the app easier to use.

On the server side, ReliaShiny is built on key R packages for reliability analysis and visualization. The WeibullR [11] package provides tools to fit and analyze Weibull distributions, which are widely used in life data analysis. The ReliaGrowR [12], [13] package helps with reliability growth modeling, allowing users to track and improve system reliability over time. The ReliaPlotR [14] package lets users create interactive reliability plots, making it easier to understand results through dynamic visualizations.

Usage

ReliaShiny is available in two primary ways: as a web application hosted online and as a local application that can be run on a user's machine. The web-hosted version is accessible via a web browser, providing a convenient option for users who prefer not to install software locally. The local version can be run by first installing the software package from CRAN or GitHub, and then launching the application using a simple command. This option is ideal for users who require offline access or wish to customize the application for their specific needs.

Web-based Example

To illustrate the functionality of the web-based application, the following example provides an overview of performing LDA using a sample dataset.

First, access the web application online at https://paulgovan.github.io/ReliaShiny/ or launch the local version using the following commands. This code assumes that the ReliaShiny package is already installed.

library(ReliaShiny)
ReliaShiny()

After launching the application, the Landing page first appears. The Landing page provides options to:

Access the Project Site and Documentation
View the Source Code Repository
Download an example dataset
Navigate to other menus within the application

The figure below shows the default Landing page.

{width=100%}

For this example, navigate to the Life Data menu and click on the Data sub-menu. The Data tab provides options for uploading and arranging data for analysis. The application also includes several example datasets that can be loaded directly, and this example use the sample "Time-to-Failure" dataset.

At this stage, the application should resemble the figure below. This figure shows the data upload and arrangement options, along with a preview of the dataset. The menu has several options for customizing the data arrangement, such as specifying censoring types and grouping variables, but this example uses the default settings.

{width=100%}

Next, navigate to the Model sub-menu to fit a reliability model to the data. The Model tab provides options for selecting the distribution type, estimation method, and other model settings. For this example, the Weibull distribution is selected with the Maximum Likelihood Estimation (MLE) method. Feel free to experiment with different configurations to tailor the model to specific needs. The figure below shows the Model tab with the selected settings.

{width=100%}

Next to the model setting options is the Weibull probability plot and a summary of the fitted model. The plot is interactive, allowing users to zoom in and hover over points to view additional information. The summary provides key statistics about the fitted model, including parameter estimates and goodness-of-fit metrics.

Finally, visit the Contour Plot tab to visualize the joint confidence region for the Weibull parameters. The contour plot displays the confidence intervals for the shape and scale parameters, providing insights into the uncertainty associated with the estimates. The figure below shows the contour plot generated by the application. This plot is also interactive, allowing users to zoom in and hover over points.

{width=100%}

Programmatic Example

For users who prefer programmatic access, ReliaShiny comes prepackaged with the ReliaPlotR package. This package provides functions for generating interactive reliability plots similar to those found in the web application. This option is ideal for users who wish to integrate reliability plotting into their existing workflows or who prefer coding over using a graphical interface.

To illustrate programmatic analysis, the following example demonstrates basic RGA using the ReliaPlotR package.

First, start by loading ReliaGrowR and ReliaPlotR in the R environment.

library(ReliaGrowR)
library(ReliaPlotR)

Next set up some example cumulative time and failure data. This data represents the times at which failures occurred during testing and the corresponding number of failures at each time point.

times <- c(100, 200, 300, 400, 500)
failures <- c(1, 2, 1, 3, 2)

Then run the RGA using the rga function from the ReliaGrowR package. This function fits a reliability growth model to the provided data and returns the results.

Finally, use the plotly_rga function from the ReliaPlotR package to create an interactive plot of the RGA results. This plot allows users to visualize the reliability growth over time and explore the data interactively.

result <- rga(times, failures)
plotly_rga(result)

The figure above shows the resulting interactive plot generated by the previous code. Similar to the plots in the web application, this plot is interactive in a web environment, allowing users to zoom in and hover over points to view additional information about the analysis.

ReliaPlotR also includes functions for generating other types of reliability plots. For example, to see how the Mean Time Between Failures (MTBF) changes over time, try the following code:

plotly_duane(result)

The previous figure shows the interactive plot generated by the previous code. Similar to the other examples, this plot is customizable, allowing users to adjust the appearance and layout as needed.

Future Work

While the project is now in a stable state, there are still several opportunities for future development and improvement. Beyond expanding existing features, such as adding more options for model fitting and visualization, there are plans to support other types of reliability analysis. A natural next step is adding tools for repairable systems, since RGA methods share many similarities with this type of analysis. This would involve implementing the right models and creating tools for working with repairable system data. Another promising direction is support for Accelerated Life Testing (ALT). ALT has requirements similar to LDA but uses different data structures and methods. WeibullR.ALT [15], an extension of WeibullR, already provides ALT-specific functions, and bringing these capabilities into ReliaShiny would be a logical next step. These additions would broaden the application’s usefulness and make it a more complete resource for reliability engineers.

As an open-source project, community contributions are encouraged. Development so far has been guided largely by user feedback and requests, and this collaborative approach will continue. Future work will reflect the changing needs and interests of the user community, with possible improvements such as new modeling options, better visualization tools, and more documentation and examples. Ongoing development may also be influenced by emerging trends and advances in the field.

Conclusion

References

Jiménez, R. C., Kuzak, M., Alhamdoosh, M., Barker, M., Batut, B., Borg, M., Capella-Gutierrez, S., Chue Hong, N., Cook, M., Corpas, M., Flannery, M., Garcia, L., Gelpí, J. L., Gladman, S., Goble, C., González Ferreiro, M., Gonzalez-Beltran, A., Griffin, P. C., Grüning, B., Hagberg, J., … Crouch, S. (2017). Four simple recommendations to encourage best practices in research software. F1000Research, 6, ELIXIR-876. https://doi.org/10.12688/f1000research.11407.1
Wilkinson, M., Dumontier, M., Aalbersberg, I. et al. The FAIR Guiding Principles for scientific data management and stewardship. Sci Data 3, 160018 (2016). https://doi.org/10.1038/sdata.2016.18
Barker, M., Chue Hong, N.P., Katz, D.S. et al. Introducing the FAIR Principles for research software. Sci Data 9, 622 (2022). https://doi.org/10.1038/s41597-022-01710-x
R Core Team, "R: A Language and Environment for Statistical Computing", R Foundation for Statistical Computing, Vienna, Austria, 2024, https://www.R-project.org/.
M. Reid, "Reliability – a Python library for reliability engineering", Version 0.8.2, 2022, https://doi.org/10.5281/ZENODO.3938000.
Chang W, Cheng J, Allaire J, Sievert C, Schloerke B, Xie Y, Allen J, McPherson J, Dipert A, Borges B (2024). shiny: Web Application Framework for R. R package version 1.9.1, https://CRAN.R-project.org/package=shiny.
Govan P (2023). WeibullR.learnr: An Interactive Introduction to Life Data Analysis. doi:10.32614/CRAN.package.WeibullR.learnr https://doi.org/10.32614/CRAN.package.WeibullR.learnr, R package version 0.1.1, https://CRAN.R-project.org/package=WeibullR.learnr.
Chang W, Borges Ribeiro B (2021). shinydashboard: Create Dashboards with 'Shiny'. R package version 0.7.2, https://CRAN.R-project.org/package=shinydashboard.
Perrier V, Meyer F, Granjon D (2024). shinyWidgets: Custom Inputs Widgets for Shiny. R package version 0.8.7, https://CRAN.R-project.org/package=shinyWidgets.
Silkworth D, Symynck J (2025). WeibullR: Weibull Analysis for Reliability Engineering. R package version 1.2.4, https://CRAN.R-project.org/package=WeibullR.
Govan P (2026). “ReliaGrowR: Modeling and Plotting Functions for Reliability Growth Analysis.” In 2026 Proceedings - Annual Reliability and Maintainability Symposium (RAMS).
Govan P (2024). ReliaGrowR: Reliability Growth Analysis. doi:10.32614/CRAN.package.ReliaGrowR https://doi.org/10.32614/CRAN.package.ReliaGrowR, R package version 0.1, https://cran.r-project.org/package=ReliaGrowR.
Govan P (2025). ReliaPlotR: Interactive Reliability Probability Plots. doi:10.32614/CRAN.package.ReliaPlotR https://doi.org/10.32614/CRAN.package.ReliaPlotR, R package version 0.4.0, https://CRAN.R-project.org/package=ReliaPlotR.
Silkworth D (2022). WeibullR.ALT: Accelerated Life Testing Using 'WeibullR'. R package version 0.7.2, https://CRAN.R-project.org/package=WeibullR.ALT.