{bidux} v0.3.3: Where Databases Meet Quick Decisions

The latest {bidux} release bridges the gap between your production data and rapid UX improvements, because sometimes the best insight is the one you can act on today.

I’m thrilled to announce that {bidux} v0.3.3 is now available on CRAN!

This release is about meeting you where you are: Whether that’s knee-deep in a database connection, racing against a deadline with Quarto, or just needing a quick UX fix without the ceremony. Because behavioral insight shouldn’t require a behavioral scientist in the room.

Your Database, Your Telemetry, Your Way

Let’s be honest: Most of our telemetry doesn’t live in neat CSV files. It lives in production databases, behind connection strings, in tables with names like user_events_v2_final_FINAL.

With v0.3.3, bid_telemetry() and bid_ingest_telemetry() now speak {DBI} fluently. Pass in your existing database connection (e.g., SQLite, PostgreSQL, MySQL, whatever you’ve got) and {bidux} will work with it directly:

library(bidux)
library(DBI)

# Your existing database connection (that you definitely already have open)
con <- dbConnect(RSQLite::SQLite(), "production.db")

# Old way: Export to file, then analyze (ugh)
# New way: Just point {bidux} at your connection
issues <- bid_telemetry(
  con,
  table_name = "shiny_events",  # auto-detection is nice, but control is nicer
  thresholds = bid_telemetry_presets("moderate")
)

# The connection stays open: {bidux} doesn't presume to manage your resources
dbDisconnect(con)  # When YOU'RE ready

This isn’t just about convenience (though it is convenient). It’s about reducing the friction between noticing a problem and fixing it. Every export-import cycle is a chance for good intentions to die in a TODO list.

Quick Suggestions for Real Humans

Sometimes you don’t need a five-stage behavioral intervention. Sometimes you just need to know: “Should this be a card layout or tabs?”

Enter bid_quick_suggest(), the function that respects your time:

# When your standup is in 10 minutes and users are confused
suggestions <- bid_quick_suggest(
  "Users can't find the export button after running analysis"
)

# Get immediate, ranked suggestions you can actually implement
print(suggestions)
# ✓ Add bslib::tooltip() to explain export availability
# ✓ Use bslib::card_header() to group export with results
# ✓ Consider shinyjs::toggleState() to enable only when ready

No stages. No ceremony. Just behavioral science applied to your specific problem, because sometimes the perfect is the enemy of the good-enough-to-ship-today.

Structure Suggestions You Can Actually Filter

The Structure stage now returns suggestions in a format that plays nicely with your existing data wrangling reflexes. Every suggestion comes as both the rich nested format and a practical tibble:

structure_result <- bid_structure(
  previous_stage = anticipate_result,
  telemetry_flags = bid_flags(issues)  # Real usage data informing suggestions
)

# Find the low-hanging fruit
quick_wins <- structure_result$suggestions_tbl |>
  filter(difficulty == "Easy", score > 0.7) |>
  select(title, components, rationale) |>
  head(3)

# Or focus on navigation issues
nav_improvements <- structure_result$suggestions_tbl |>
  filter(category == "Navigation") |>
  arrange(desc(score))

This isn’t just about making data rectangular; it’s about making insights actionable. When you can filter() and arrange() your way to the next improvement, you’re more likely to actually make it.

Better Sources, Better Science

We’ve also strengthened our theoretical foundations. The Beautiful-Is-Good Stereotype now properly cites both its social psychology origins (Dion et al., 1972) and its UX applications (Tractinsky et al., 2000). The Data Storytelling Framework references the actual visualization experts (Knaflic, 2015; Dykes, 2020).

These become useful breadcrumbs for when you need to dig deeper, to defend a design decision, or to learn more about why that suggestion actually works.

Quarto Dashboards? We’ve Got You

The documentation now explicitly supports Quarto dashboard developers. While {bidux} was born in the Shiny world, most of our suggestions translate beautifully to Quarto’s static and server: shiny contexts:

• Static Quarto dashboards: Layout suggestions, component recommendations, and the full BID framework apply directly
• Interactive Quarto (with server: shiny): Everything works, including telemetry integration

Because good UX principles don’t care about your rendering engine.

A Tool That Respects Your Context

What I love about this release is how it meets people where they are. Got a database? Connect directly. Need something quick? bid_quick_suggest(). Want to integrate with your dplyr workflow? Here’s a tibble. Building in Quarto? We support that too.

This is what cognitive engineering looks like in practice: Reducing the cognitive load of reducing cognitive load. Making the right thing the easy thing.

Install and Explore

install.packages("bidux")

For the full details, including migration notes and comprehensive examples, check out the release on GitHub (opens in new tab).

What’s Next?

Every release teaches us something about how people actually use behavioral science in production. Your telemetry databases, your quick fixes, your Quarto dashboards: They all inform where {bidux} goes next.

So please, open issues (opens in new tab), share your workflows, tell us what friction you’re facing. Because the best tools are built in conversation with the people who use them.

Happy designing, and remember: Sometimes the best behavioral intervention is the one that ships today 🚀