Case study · athenahealth

Report Builder

Build a query, inspect the result, and refine in one workspace.

Report Builder at a glance

Shipped

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
Report Builder prototype: columns and filters on the left, the live result below, synthetic data.

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.

Try prototypePassword required
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

Before RITE

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.

After RITE

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.

What testing changed. RITE moved the result table into a bottom drawer, so choosing attributes and seeing what is added and active could sit side by side, with the result still in view below. The configure-and-preview model stayed the same. Layouts are schematic, not the tested screens. Diagram drawn for this portfolio; not an original artifact.
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

Reasoning in context

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.
Working prototype · Synthetic data
Report Builder edit screen showing selectable report attributes, reordered columns, and query results visible in the same workspace
Select columns while keeping the result in view. Users can choose and reorder report fields, then immediately inspect how those decisions shape the output.
My first model

One attribute list for everything

All attributes
Columns
Filters
Filter-only attributes offered as columns, column-only attributes offered as filters
After adjacent teams' needs

Two selections, one workspace

Column attributes
Filter attributes
Select columns
Select filters
Shared configure ↔ preview workspace
The reshape. Separating the two tasks fixed the model without breaking the workspace people already understood. Diagram drawn for this portfolio; not an original artifact.
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.

Illustrative component state · not an original interface
Find insurance packagesCompany or plan name
Aetna
Package ID (optional)
e.g. DEMO-PKG-101
Search
Matching packages
Aetna Open Choice PPOAetna · DEMO-PKG-101
Aetna Open Access Elect ChoiceAetna · DEMO-PKG-102
2 selected · retained across searchesAetna Open Choice PPO DEMO-PKG-101UnitedHealthcare Choice Plus DEMO-PKG-201 · selected earlier
U.S. insurer and plan names are public examples. All IDs are synthetic; this is a static illustration. Sources: Aetna PPO, Aetna EPO, UnitedHealthcare Choice Plus.

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.

Illustrative reporting date picker · interactive · not an original interface
Filter Date of service Chosen in the filter panel
Date type
Last
Selected Example run date: Oct 6, 2026
An interactive reconstruction, drawn for this portfolio with synthetic dates. It shows the kinds of date conditions reporting users needed: relative periods that move with each run, single dates, ranges and whole months. The remembered contribution is influencing support for relative dates alongside fixed-date choices; the presets, fields and behaviour here are illustrative.

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 keptHow the translation worked
Connect configuration to resultsThree 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
A benchmark, not a spec. The validated direction defined what had to survive the platform change; implementation choices were made against it. Diagram drawn for this portfolio; not an original artifact.

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.

ChoseConfiguration beside a live result
Gave upMore room for filter controls
Why it was worth itWe kept the preview. RITE then pointed to layout and spacing changes: more filters visible in one view, and active filters that were easier to scan.
ChoseA shared foundation, not full standardization
Gave upMaximum reuse across teams
Why it was worth itWith the adjacent team we agreed to keep three things domain-specific: Boolean-style filtering, hierarchical multi-select and each product's entry points. The difference was a decision, not drift.
ChoseThe embedded platform’s controls
Gave upSome interactions exactly as designed
Why it was worth itThe platform kept reporting inside the product people already used. Where its controls fell short, I worked with the vendor’s support team on scanning active filters and clearing them quickly.
ChoseBuild the most critical pieces first
Gave upThe full design in the first release
Why it was worth itWorking with engineering on what could be built, I prioritised the most critical interactions for development and moved the rest to the backlog, so the release kept what mattered most.
ChoseTime on cross-team alignment
Gave upDesign production time
Why it was worth itAlignment took roughly half my time while it was active. It also exposed the flaw in my combined columns-and-filters model before RITE testing.

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.

From a metric drill-downInsights page → click a metric → open the underlying dataShipped first
From a saved queryReturn to a configured report and refine itShipped
From scratchThe standalone builderFollowed
One Report Builder pattern: configure ↔ preview ↔ refine
Reached from wherever users are. The pattern had to hold together whichever way people arrived. Diagram drawn for this portfolio; not an original artifact.
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.