Interactive Data Applications with Shiny (SHID01)
Interactive Data Applications with Shiny is a practical R Shiny course for researchers focused on building, customising, and deploying interactive web applications from data analyses.
Duration: 2 Days, 6 hours per day
Next Date: April 28-29, 2026
Format: Live Online Format
UK (GMT+1) local time - All sessions will be recorded and made available to ensure accessibility for attendees across different time zones.
£300Registration Fee
Register NowLike what you see? Click and share!
5.0
from 200+ reviews
- Overview
- Instructors
- Schedule
Course Description
This two-day workshop provides a comprehensive introduction to building interactive web applications for statistical analysis and data exploration using R Shiny. The course focuses on developing fundamental skills and mental models through instructor-led live coding, building progressively from simple examples to realistic statistical applications. Day 1 establishes the foundations: understanding Shiny’s three-part structure (UI, server, app), the reactive programming model that connects inputs to outputs, building interfaces with various input widgets and output types, implementing layouts for multi-element applications, and creating interactive statistical applications with proper reactive dependencies. Day 2 extends to more complex patterns: advanced reactivity including dependent inputs and observer patterns, debugging reactive applications, building multi-panel applications with tabbed interfaces, implementing interactive graphics features like selection and coordinated views, polishing applications for deployment, and deploying to shinyapps.io for web-based sharing. Through hands-on practice with statistical analysis interfaces and data visualization applications, participants gain both conceptual understanding of reactive programming and practical skills for building functional applications. The emphasis throughout is on building sufficient foundational competence that participants can continue learning advanced topics independently, rather than comprehensive coverage of the entire Shiny ecosystem.
What You’ll Learn
During the course we will cover the following:
- Understand the reactive programming model that underlies Shiny and how it differs from script-based R programming.
- Build Shiny applications using the three-part structure: user interface (UI) definition, server logic, and application binding.
- Create user interfaces with multiple input types: sliders, select boxes, radio buttons, text inputs, and other widgets.
- Implement various output types in applications: plots, tables, formatted text, and other display elements.
- Connect inputs to outputs through server-side reactive computations that automatically update when inputs change.
- Build interactive visualizations by integrating Shiny with ggplot2 and other plotting packages.
- Implement page layouts using sidebar layouts, panels, and other organizational structures for multi-element applications.
- Structure server logic for clarity and efficiency when building statistical analysis interfaces.
- Use reactive expressions and understand reactive dependencies: when code re-executes and why.
- Implement dependent inputs where one widget’s range or choices depends on another widget’s value using observer patterns and dynamic UI updates.
- Build applications with multiple linked outputs that share reactive computations efficiently.
- Debug reactive applications using diagnostic strategies to understand reactive flow and identify errors.
- Recognize and fix common errors that arise when working with Shiny’s reactive programming model.
- Create multi-panel applications with tabbed interfaces to organize multiple views or analysis outputs.
- Implement more sophisticated layouts for applications with multiple coordinated components.
- Build interactive graphics with selection capabilities: selecting plot regions, selecting individual points, and extracting selected data.
- Create coordinated views where interaction in one plot updates or filters another plot.
- Add titles, instructions, and helpful interface elements to make applications usable by others.
- Deploy Shiny applications to shinyapps.io for sharing via web links without managing servers.
- Structure code for larger applications to maintain readability and maintainability.
- Navigate Shiny documentation, example galleries, and community resources effectively.
- Understand what topics to learn next for more advanced applications: Shiny modules, specialized packages, performance optimization.
- Apply Shiny to create interactive interfaces for your own statistical analyses and data visualizations.
- Build sufficient foundational skills to continue learning advanced Shiny topics independently through documentation and examples.
Course Format
Interactive Learning Format
Each day features a well-balanced combination of lectures and hands-on practical exercises, with dedicated time for discussing participants’ own data, time permitting.
Global Accessibility
All live sessions are recorded and made available on the same day, ensuring accessibility for participants across different time zones.
Collaborative Discussions
Open discussion sessions provide an opportunity for participants to explore specific research questions and engage with instructors and peers.
Comprehensive Course Materials
All code, datasets, and presentation slides used during the course will be shared with participants by the instructor.
Personalized Data Engagement
Participants are encouraged to bring their own data for discussion and practical application during the course.
Post-Course Support
Participants will receive continued support via email for 30 days following the course, along with on-demand access to session recordings for the same period.
Who Should Attend / Intended Audiences
This course is designed for researchers, data analysts, and scientists who use R and want to create interactive interfaces for statistical analyses or data exploration without needing prior experience in Shiny or web development. It is suitable for participants who are comfortable working in R—loading and manipulating data, writing functions, and reading and modifying code—and who have a basic understanding of statistical concepts such as distributions, regression, and exploratory data analysis. Familiarity with ggplot2 and RStudio is helpful but not essential. The course emphasises developing strong mental models and core competence in Shiny application development through hands-on, instructor-led coding, with the goal of enabling participants to independently build and share interactive data exploration tools and dashboards rather than covering every available feature.
Equipment and Software requirements
A laptop or desktop computer with a functioning installation of R and RStudio is required. Both R and RStudio are free, open-source programs compatible with Windows, macOS, and Linux systems.
A working webcam is recommended to support interactive elements of the course. We encourage participants to keep their cameras on during live Zoom sessions to foster a more engaging and collaborative environment.
While not essential, using a large monitor—or ideally a dual-monitor setup—can significantly enhance your learning experience by allowing you to view course materials and work in R simultaneously.
All necessary R packages will be introduced and installed during the workshop. A comprehensive list of required packages will also be shared with participants ahead of the course to allow for optional pre-installation.
Dr. Mark Andrews
Mark is a psychologist and statistician whose work lies at the intersection of cognitive science, Bayesian data analysis, and applied statistics. His research focuses on developing and testing Bayesian models of human cognition, with a particular emphasis on language processing and memory. He also works extensively on the theory and application of Bayesian statistical methods in the social and behavioural sciences, bridging methodological advances with real-world research challenges.
Since 2015, Mark has co-led a programme of intensive workshops on Bayesian data analysis for social scientists, funded by the UK’s Economic and Social Research Council (ESRC). These workshops have trained hundreds of researchers in the practical application of Bayesian methods, particularly through R and modern statistical packages.
Education & Career
• PhD in Psychology, Cornell University, New York (Cognitive Science, Bayesian Models of Cognition)
• MA in Psychology, Cornell University, New York
• BA (Hons) in Psychology, National University of Ireland
• Senior Lecturer in Psychology, Nottingham Trent University, England
Research Focus
Mark’s work centres on:
• Bayesian models of human cognition, especially in language processing and memory
• General Bayesian data analysis methods for the social and behavioural sciences
• Comparative studies of Bayesian vs. classical approaches to inference and model comparison
• Promoting reproducibility and transparent statistical practice in psychological research
Current Projects
• Developing Bayesian cognitive models of memory and linguistic comprehension
• Exploring Bayesian approaches to regression, multilevel, and mixed-effects models in psychology and social science research
• Co-leading ESRC-funded workshops on Bayesian data analysis for applied researchers
Professional Consultancy & Teaching
Mark provides expert training and advice in Bayesian data analysis for academic and applied research projects. His teaching portfolio includes courses and workshops on:
• Bayesian linear and generalized linear models
• Multilevel and mixed-effects models
• Cognitive modelling with Bayesian methods
• Applied statistics in R for psychologists and social scientists
He is also an advocate of open science and is experienced in communicating complex statistical methods to diverse audiences.
Teaching & Skills
• Instructor in Bayesian statistics, time series modelling, and machine learning
• Strong advocate for reproducibility, open-source tools, and accessible education
• Skilled in R, Stan, JAGS, and statistical computing for large datasets
• Experienced mentor and workshop leader at all academic levels
Links
• University Profile
• Personal Page
• ResearchGate
Session 1 – 02:00:00 – Introduction to Shiny and Basic Structure
This session establishes foundational understanding of Shiny applications and the reactive programming model. We begin with the simplest possible Shiny application to understand the three-part structure: user interface (UI) definition using functions like fluidPage, server logic that connects inputs to outputs, and the shinyApp binding that creates the application. The reactive programming model is introduced through minimal examples, demonstrating how user inputs automatically trigger updates to outputs without explicit control flow or loops. Through instructor-led live coding, participants build their first applications starting from single-input, single-output examples (such as a histogram with a slider controlling bin width) and gradually adding elements. The session emphasizes understanding why Shiny code is structured as nested function calls and how this differs from typical script-based R where commands execute sequentially. We explore the basic pattern: input widgets in the UI, renderPlot and similar functions in the server, and how input$ and output$ objects mediate the connection. By the end of the session, participants understand the basic template pattern and can create simple interactive graphics with controls.
Break – 01:00:00
Session 2 – 02:00:00 – Inputs, Outputs and Layouts
This session expands the toolkit of interface components and demonstrates combining multiple elements effectively. We cover various input widget types: sliderInput for numeric ranges, selectInput for dropdown menus, radioButtons for exclusive choices, textInput for user text, and others. Different output types are demonstrated: plotOutput for graphics, tableOutput for data tables, verbatimTextOutput for formatted text, and how each connects to corresponding render functions (renderPlot, renderTable, renderPrint) in the server. The session explains how inputs and outputs connect through ID-based references: the ID specified in the UI must match the ID used in the server to access values or render outputs. Page layout components are introduced, showing how to organize multiple inputs and outputs using sidebarLayout with sidebarPanel and mainPanel, as well as other layout functions for arranging elements. Through building progressively more complex applications with multiple controls affecting multiple outputs, participants develop fluency with the standard patterns. Examples include interactive scatter plots with controls for variables, colors, and sizing, and applications that display both graphical and tabular output from the same reactive computation.
Break – 01:00:00
Session 3 – 02:00:00 – Building Statistical Applications
This session demonstrates building realistic statistical interfaces that participants might use in their own work. Working through complete examples of statistical applications—such as interfaces for exploring likelihood functions, visualizing sampling distributions, or interactive regression diagnostics—participants see how Shiny serves practical analytical needs. The session covers organizing application logic: structuring server code with clear reactive expressions, separating data preparation from visualization, and creating readable code for applications with multiple components. Reactive dependencies are explored more thoroughly: understanding the reactive graph (which outputs depend on which inputs), recognizing when computations will re-execute, and structuring code so expensive computations only re-run when necessary. We use interface elements like helpText and well-structured layouts to guide users through analyses. The session includes integrating ggplot2 visualizations within reactive rendering, passing reactive values to plotting functions, and updating complex graphics based on user interaction. By the end of Day 1, participants can construct functional statistical interfaces, understand the reactive flow that connects user actions to computational results, and have mental models for how Shiny applications execute.
Session 4 – 02:00:00 – Advanced Reactivity and Dependencies
This session addresses sophisticated reactive patterns needed for realistic applications where inputs depend on each other or multiple outputs share computations. Dependent inputs are covered in detail: using observeEvent to watch for changes in one input and updateSliderInput (or updateSelectInput, etc.) to modify another input’s range, choices, or value accordingly. This pattern is demonstrated through examples like setting valid ranges based on user selections or filtering choice lists based on previous selections. The session covers sharing reactive computations across multiple outputs efficiently, avoiding redundant calculations when multiple outputs need the same processed data. The reactive execution model is examined in greater depth: building participants’ mental model of how Shiny’s reactive graph determines execution order, understanding reactive contexts, and recognizing why certain code patterns work while others fail. Debugging reactive applications receives explicit attention with practical strategies: using print statements and browser() to inspect reactive flow, understanding error messages that arise from reactive context violations, identifying why outputs aren’t updating as expected, and fixing timing issues in reactive code. Through working with applications having complex reactive dependencies, participants develop troubleshooting skills essential for independent work.
Break – 01:00:00
Session 5 – 02:00:00 – Multi-Panel Applications and Interactive graphics
This session demonstrates organizing larger applications with multiple components and implementing interactive graphics features beyond basic plotting. Tabbed interfaces are covered using tabsetPanel and tabPanel, showing how to create applications with multiple views of data, different analysis outputs, or distinct functional sections within one application. More sophisticated layouts are introduced using fluidRow and column for grid-based arrangements, or other layout approaches for applications requiring multiple coordinated panels. The session covers structuring code for larger applications: organizing server logic by functional section, using clear naming conventions, and commenting code for maintainability. Interactive graphics features are demonstrated: implementing brush selection to select regions in plots, using brushedPoints to extract data from selected regions, creating linked plots where selection or zooming in one plot updates another, and other interactive patterns for data exploration. Practical examples show building complete multi-panel applications that integrate these features, such as applications with exploratory plots, diagnostic panels, and summary tables that respond to user selections. The session emphasizes keeping applications comprehensible as complexity increases.
Break – 01:00:00
Session 6 – 02:00:00 – Polishing, Deployment and Moving Forward
The final session covers making applications ready for sharing and establishes paths for continued independent learning. Application polish is addressed: adding clear title panels, using helpText effectively to guide users, organizing layouts for intuitive use, providing feedback on long computations, and making applications accessible to non-expert users. Deployment to shinyapps.io is demonstrated step-by-step: creating an account, configuring deployment from RStudio, publishing applications, and sharing via web links. Participants deploy one of their course applications to understand the complete workflow from development to sharing. Debugging strategies are reviewed comprehensively: common error patterns (reactive context errors, missing inputs, incorrect IDs), how to diagnose each type systematically, and using RStudio’s debugging tools effectively with Shiny applications. Resources for continued learning are provided and discussed: official Shiny documentation structure and how to navigate it, the Shiny gallery for finding example code, key next topics for advancing skills (Shiny modules for larger applications, specialized widget packages like DT and plotly, performance considerations for applications with many users), and recommended learning paths. The session concludes with participants enhancing course applications based on their interests and discussing their specific use cases. By the end, participants have complete workflow skills from building to deploying applications, troubleshooting capabilities for diagnosing problems independently, and clear direction for continued learning of advanced topics.
Testimonials
PRStats offers a great lineup of courses on statistical and analytical methods that are super relevant for ecologists and biologists. My lab and I have taken several of their courses—like Bayesian mixing models, time series analysis, and machine/deep learning—and we've found them very informative and directly useful for our work. I often recommend PRStats to my students and colleagues as a great way to brush up on or learn new R-based statistical skills.
Rolando O. Santos
PhD Assistant Professor, Florida International University
Courses attended
SIMM05, IMDL03, ITSA02, GEEE01 and MOVE07
Testimonials
PRStats offers a great lineup of courses on statistical and analytical methods that are super relevant for ecologists and biologists. My lab and I have taken several of their courses—like Bayesian mixing models, time series analysis, and machine/deep learning—and we've found them very informative and directly useful for our work. I often recommend PRStats to my students and colleagues as a great way to brush up on or learn new R-based statistical skills.
Rolando O. Santos
PhD Assistant Professor, Florida International University
Courses attended
SIMM05, IMDL03, ITSA02, GEEE01 and MOVE07
Testimonials
PRStats offers a great lineup of courses on statistical and analytical methods that are super relevant for ecologists and biologists. My lab and I have taken several of their courses—like Bayesian mixing models, time series analysis, and machine/deep learning—and we've found them very informative and directly useful for our work. I often recommend PRStats to my students and colleagues as a great way to brush up on or learn new R-based statistical skills.
Rolando O. Santos
PhD Assistant Professor, Florida International University
Courses attended
SIMM05, IMDL03, ITSA02, GEEE01 and MOVE07
Frequently asked questions
Everything you need to know about the product and billing.
When will I receive instructions on how to join?
You’ll receive an email on the Friday before the course begins, with full instructions on how to join via Zoom. Please ensure you have Zoom installed in advance.
Do I need administrator rights on my computer?
I’m attending the course live — will I also get access to the session recordings?
I can’t attend every live session — can I join some sessions live and catch up on others later?
I’m in a different time zone and plan to follow the course via recordings. When will these be available?
I can’t attend live — how can I ask questions?
Will I receive a certificate?
When will I receive instructions on how to join?
You’ll receive an email on the Friday before the course begins, with full instructions on how to join via Zoom. Please ensure you have Zoom installed in advance.
Do I need administrator rights on my computer?
I’m attending the course live — will I also get access to the session recordings?
I can’t attend every live session — can I join some sessions live and catch up on others later?
I’m in a different time zone and plan to follow the course via recordings. When will these be available?
I can’t attend live — how can I ask questions?
Will I receive a certificate?
Still have questions?
Can’t find the answer you’re looking for? Please chat to our friendly team.
