Report Builder
Build a query, inspect the result, and refine in one workspace.
Report Builder at a glance
A self-service query workspace in athenahealth’s reporting product: columns and filters on one side, the live result on the other.
Outcome. Shipped in stages: metric drill-down first, then saved queries, then the standalone builder.
- 7 + 2
- CSM experts and PMs in discovery
- 8
- users in RITE testing
- 4.3/5
- self-rated task completion
- 2
- entry points shipped

My roleSole designer, discovery to handoff · Created the shared foundation · Drove component standardisation across teams · Carried it through the Sigma platform shift
The result stays in view
People see the effect of every column and filter while they build, instead of building blind.
Columns separated from filters
Other teams’ data showed some fields only filter and others only display, so I split the two choices.
One foundation, three deliberate differences
Shared parts standardised; Boolean filters, hierarchy and entry points kept specific to each team.
Full case study
Problem
Users understood practice-specific reporting needs, but translating those needs into fields and filters was complex. Configuration and results needed to stay connected.
Context
Self-service reporting aimed to help CSMs and other analytics-capable users build or adapt reports. The work later adapted to an organization-wide Sigma platform shift.
Explore the context
Report Builder let people build their own reports on athenahealth's newer data platform: pick fields, set filters, run the query. Users knew reporting, not data platforms, so it had to feel like reporting, not database work.
More context
Report Builder was the self-service reporting experience for the newer, modernizing data platform at athenahealth. Where the legacy reporting library gave users access to standard and saved reports, Report Builder gave them the ability to construct reports themselves — selecting the data fields they wanted, defining the filters that narrowed the view, and running the resulting query.
The broader operating-model goal was to move routine, use-case-specific report creation closer to CSMs and other analytics-capable users who understood practice demand. That could reduce developer dependency for individual reports and leave engineering capacity for the platform and more complex work. This was an intended resource-allocation benefit, not a measured result; the exact CSM remit and level of adoption remain unconfirmed.
The users were experienced with reporting but not with data platforms. The design had to make constructing a query feel like a reporting activity, not a database activity.
Report Builder was one of my first pieces of work on the reporting product line. It also became the surface where cross-team design collaboration with adjacent product-line teams shaped the direction.
Role
I was the lead and sole designer. I led discovery, interaction design, prototyping and RITE iteration, created the configure-and-preview foundation and drove the effort to standardise its components across product lines. I ran the cross-team alignment sessions jointly with a designer from an adjacent product line. Product owned the roadmap.
Read ownership details
My role and research
I was the lead and sole designer; Product owned the roadmap. Discovery drew on seven CSM subject-matter experts and two PMs from other teams. A separate group of eight users tested the prototype in RITE sessions.
More on my role and the research groups
Lead UX/UI Designer, sole designer on Report Builder. Product ownership sat with Product Management. My work went beyond receiving requirements — SME conversations, problem framing, interaction design, cross-team alignment, RITE-based validation.
My manager was a thinking partner and, during the later platform-adaptation work, a co-explorer as we both learned the newer platform's capabilities and constraints.
Early discovery included seven CSM subject-matter experts and two product managers from other teams. After that discovery work, I brought a clean prototype to eight real users for RITE usability testing. The discovery group and RITE participants were distinct stages, not one combined sample.
Process
Discovery involved seven CSM subject-matter experts and two PMs from other teams. Eight users then tested the prototype in RITE sessions; I updated it after each session.
Eight RITE participants · Core model supported · Layout and filter scanability refined
The result table on the left; configuration in a panel on the right. What was added and active was harder to see at a glance.
Choose attributes on the left; the right shows the columns and filters that are added and active; the result table sits in a drawer at the bottom.
Explore research and validation
Research changed the direction
A direction existed before I joined, but it didn't match how people reasoned while building a report. Research showed they needed to see the result while configuring, not build, run, find a mistake and start over.
What the research surfaced
A design direction for query configuration existed before I joined, but I was not convinced it addressed how people reasoned while building a report. I led a visioning phase grounded in resonance research: using early concepts to learn which problems, mental models, and interaction ideas felt meaningful before committing to a solution.
I combined those reactions with conversations with subject-matter experts, the product owner, my manager, and existing research. The problems were more specific than the prior direction was addressing:
- Understanding data definitions well enough to know which fields to select
- Building a query quickly, without having to hold too much in memory across steps
- Being able to preview the data result while configuring the query, to verify the query was returning what they intended
- Saving ad-hoc queries with configured columns and filters
- Sharing configurations with colleagues
- Scheduling recurring runs
These findings changed the direction: I designed a connected workspace where users could construct a report, inspect its output, and correct their choices without starting over.
Four experience principles
See results while building
Keep configuration and its result in one experience so people can evaluate choices without carrying the query model across disconnected steps.
Keep choices visible
Show selected columns, active filters, and their effect on the result so users can understand what shaped the answer.
Use the right control
Use interaction patterns suited to the attribute—such as relative dates, value search, Boolean conditions, or hierarchy—instead of forcing one generic filter control.
Stay consistent where it helps
Align the recognizable query-building foundation across products while retaining differences required by each domain and entry point.
Why the workspace is dense, and how that was managed
Keep the question, configuration, and result close together.
Users could inspect the preview while building, then refine columns and filters without losing the question they were trying to answer. Keeping that context visible made the workspace denser. RITE testing supported the core interaction; iteration focused on layout and spacing so more filter controls fit in one viewport and active filters were easier to scan.
These principles are a retrospective synthesis of the decisions described in this case study, not a formal company framework.
Validation: RITE testing
Eight users tested the direction in RITE sessions. Asked to rate how well they completed the whole task on a 1–5 scale, five rated it 4 and two rated it 5, an average of 4.3. I updated the prototype after each session. Testing confirmed the model and tightened the screen.
We tested the Report Builder direction through RITE usability testing with eight real users. I asked participants to rate their completion of the whole task on a 1–5 scale: five rated it 4 and two rated it 5, an average of 4.3. This is a self-reported measure, not an observed completion rate. Participants understood the experience without confusion. The evidence was mainly qualitative: what participants understood and where they struggled. After each session, I made relevant prototype changes in response. Participants could understand and use the core interaction: configure the query, inspect the result, distinguish columns from filters, and refine the active state without leaving the workspace.
RITE identified changes in layout, spacing, the number of filter controls visible within one viewport, and the scanability of active filters. This was the accepted trade-off to manage: preserve the contextual preview while tightening the workspace. The underlying interaction model did not require conceptual rework.
This supports a claim of early usability and comprehension. It does not establish higher engagement after launch; that would require comparative product analytics.
Key Decisions
- Keep configuration beside results. The contextual preview supported iterative reasoning. The denser workspace required tighter spacing and more scannable active filters.
- Separate columns from filters. Cross-team feedback exposed the limits of a combined attribute list. Two distinct selections made output and filtering intent clearer.
- Share patterns, allow domain differences. Align the interaction foundation while letting controls fit different data needs.
- Carry intent through the platform shift. Use the validated direction as a benchmark when adapting the experience to Sigma.
One attribute list for everything
Two selections, one workspace
Explore designs and alternatives
The interaction model
A configuration rail held fields and filters; the main workspace kept selected attributes and query results together. Users could configure, inspect the effect, and refine the report without leaving the page.
Complex filtering and configuration
Filtering was the hardest part. One shared foundation held it together, but the control changed with the attribute: a period selector for dates, multi-select for categories, and for adjacent teams, Boolean composition and hierarchical multi-select.
More on the filter controls
The reference shown here includes two of the control patterns that emerged from the design work: a period selector for a date attribute, and a categorical multi-select for taxonomies with a manageable list of values. Adjacent product teams later needed variations of this — including more complex Boolean-style composition, and a hierarchical multi-select for a domain-specific measure taxonomy with a much deeper tree structure. Those variations shared this same interaction foundation but used control types fitted to their domains.
Filtering was where the interaction design got hardest — and where a single, uniform control would have been the wrong answer.
Some filter needs were simple: pick a value, apply a filter. Others were substantially more complex — different attribute types require different configuration controls to be usable. A date range needs a period selector. A categorical attribute needs a multi-value selector. Forcing every filter into one uniform control would either flatten these into an unusable lowest common denominator or force users through configuration steps that didn't fit what they were trying to do.
The interaction foundation was the same — searchable, categorized filter attributes on one side; configured filters on the other; results below — but the specific control used to configure each filter adapted to the type of attribute.
Decision: separate columns from filters
Adjacent teams showed my first model was wrong: some attributes only narrow the data, others only belong in the result. I separated choosing columns from choosing filters, inside the same workspace.
Cross-team collaboration
The configure-and-preview foundation was my design, and I drove the effort to standardise it across product lines. I ran the alignment sessions jointly with a designer from an adjacent product line. Teams aligned on the shared foundation and deliberately kept three needs domain-specific: Boolean filtering, hierarchical multi-select and different entry points.
How the alignment worked
The query-configuration problem existed across multiple product-line teams at athenahealth, and organizational awareness of that overlap pre-existed my involvement. I brought my Report Builder foundation into that alignment and drove the effort to standardise its components. The alignment sessions were run jointly with a designer from an adjacent product line, both of us designated as design leads for that effort. We worked through UX-level frictions between ourselves before they reached the wider group, and kept the broader cross-functional team informed.
As more teams joined, we aligned on the shared configure-and-preview foundation while preserving three domain-specific needs: Boolean filtering, hierarchical multi-select, and different entry points into the query experience.
This collaboration made the pattern more durable because consistency was deliberate rather than absolute. I explore that judgment further in Your Users Don't Care How Your Teams Are Organized.
Design-system contributions
Report Builder needs fed back into the design system: an insurance-package search-and-add pattern, and relative dates in the date picker. I remember the components, not the exact original fields.
01 · Find packages, then filter claims
Task: find claim IDs associated with selected insurance packages. A user may know a company or plan name, or arrive with a package ID.
Component challenge: support searching and building a selection together. A new search should not make previously chosen packages disappear from the user’s view.
Query connection: selected package IDs become filter values; Claim ID is an output column. For example, a synthetic result could pair DEMO-CLM-001 with DEMO-PKG-101. Claim IDs and package IDs serve different purposes.
Edge cases to demonstrate: no matches, similar names with different IDs, selecting across searches, preventing duplicate selections, and removing a selection. These are proposed reconstruction scenarios, not a record of tested original behavior.
02 · Express a moving reporting period
Task: run a claims query for a specific date, a fixed range, or a relative period such as “Last 30 days.”
Component challenge: make the type of date condition explicit. A saved fixed range keeps its dates; a relative condition is evaluated against the run date.
Pick a start date, then an end date.
Questions for the component specification: rolling days or completed calendar periods? Is today included? Which time zone applies? What changes when the user switches modes? These details need explicit rules before implementation.
Design-system value: a query-building need can reveal a gap in a shared component. My contribution was the search-and-add edge case and influence on date options; broader adoption and measured impact are not established here.
Adapting through the platform shift
When the company moved its analytics to Sigma, the validated direction became the benchmark. I kept three priorities and translated each through what the platform did directly, its built-in controls, or work with the vendor.
| Design intent kept | How the translation worked |
|---|---|
| Connect configuration to results | Three routes, depending on the interaction: 1. Achieved directly on the new platform 2. Rebuilt with the platform's out-of-the-box controls 3. Worked through with the vendor's technical team, for example making all active filters scannable and clearing filters a fast, deliberate action |
| Expose applied filters | |
| Refine without losing context |
More on the platform translation
When the company's analytics strategy shifted to Sigma, the validated direction became an experience benchmark rather than a screen-by-screen specification. Within Sigma's constraints, I preserved three priorities: connect configuration to results, expose applied filters, and let users refine without losing context. Sigma remained embedded within athenaOne.
The translation was not free. Some interactions could be achieved directly, others had to use Sigma's out-of-the-box controls, and some required conversations with the platform vendor's technical team.
The technical collaboration I remember most concretely:
- Working with the platform vendor's support team on specific capability gaps — for example, how to surface all currently active filters in a way users could scan, and how to make clearing applied filters a fast, deliberate action rather than an incidental one. These are the small interactions that make configuration usable at scale; they're also the interactions that are easy to lose in translation across platforms.
- Working with my manager to think through how our design intent could be realized within the platform's control model. Some of this was collaborative discovery — we were both learning the platform.
Trade-offs
Each decision cost something. These are the ones I remember weighing, and how we managed the cost.
Reconstructed from memory. The costs are my judgment; none were measured.
Outcome
The interaction direction carried into production: metric drill-down shipped first, opening saved queries also shipped, and the standalone builder followed. No quantified engagement or efficiency improvement is claimed.
Read outcome details
Outcome: where the direction landed
The drill-down entry shipped first, and opening a saved query also shipped; the standalone builder followed. The pattern held whichever way people arrived.
The evidence supports usability, cross-team convergence and continuity of design intent, not a measured increase in engagement.
More on the outcome
Report Builder was also the surface for a specific user flow that connected reporting into the broader product experience: a user could land on an insights page, click a metric in a visualization, drill down into the underlying data, and open the drill-down result in Report Builder to refine the query further. The drill-down flow shipped first; the standalone from-scratch query-building experience followed.
The pattern was: reporting is not a destination users go to; it's a set of capabilities users reach for from wherever they are in the product. The Report Builder pattern needed to hold together whether it was reached from a metric drill-down, from a saved query, or from the standalone experience.
Claim boundary. The original direction was validated early and used as a design benchmark; the later work adapted it to Sigma. The evidence here supports comprehension, usability, cross-team convergence, and continuity of design intent—not a quantified engagement increase.
Lessons
- Understand the data before shaping the screen. The columns-versus-filters change came from how attributes behave in the data, not from layout preference. Knowing the structure first would have saved a round of rework.
- The right trade-off can make the journey shorter. Keeping the live preview meant accepting a tighter workspace, and starting from a metric drill-down meant users began with a question they already had instead of a blank builder.
- Design with the platform, not around it. When the platform changed, the validated interaction intent became the benchmark for mapping each need onto what the new system could do.
Read more reflections
Share a foundation without flattening domain needs. A common pattern made the experience predictable across teams, while each filter control still fitted its kind of data: dates, categories, hierarchies.
Cross-team feedback should reshape the solution. Adjacent teams exposed the weakness in my combined columns-and-filters model. That improved the shared foundation rather than simply being absorbed into it.
Reporting is a capability, not a destination. The builder had to hold together whether people arrived from a drill-down, a saved query, or a blank start, so the system mattered more than any single screen.