Log Inspector

Hidden data made visible, step by step.

Team
1 PM, 8 engineers
Role
Product Designer · sole designer, end to end
Timeline
6 months

Outcome

Hours of guesswork became minutes of clarity.

90%

Faster support resolution

Enabling support team to resolve customer issues directly using the tool.

34%↓

Fewer support tickets

Enabling users to troubleshoot issues independently.

Overview

Redox is where scattered patient data finally gets along.

Hospitals, clinics, and apps all speak different data languages. Redox translates between them so patient data keeps moving and stays connected.

I designed Log Inspector to open it up and give users clarity, visibility, and control over how their sensitive data moves through Redox.

A message moving through Redox from source system to destination
Redox moving a message between two systems that do not share a data language.

The problem

Data went in, data came out. What happened in between was a mystery.

When something failed, customers had no way to see where or why, so they lost hours troubleshooting.

A message entering and leaving Redox, with everything in between hidden inside a black box
Data went in and came out. Everything in between was a black box.

Process

Understanding the users

Technical · Developers & engineers

  • Want to dig into the code and the detail of every transformation.

Non-technical · Implementation specialists

  • Want a clear, simple picture of what happened, without the code.

The challenge

Serve both without building two separate tools.

Understanding the underlying data

Data in Redox doesn’t move in a straight line. A single field can be added, deleted, moved, or reformatted across more than ten processing steps before it lands. So I traced one.

One field followed through every processing step, showing where it was altered
Step 07 dropped the middle name because the destination had no field for it, but the change wasn’t flagged as an error.

Exploring designs

The complexity made it essential to design an experience anyone could understand at a glance. Since we weren’t sure which audience to prioritize, I explored separate approaches before combining them into a single experience where users can toggle between levels of detail.

Two explorations of the same message: a plain summary view and a detailed code view
The same message, two different views

What testing changed

  1. 01

    Changes marked, not just shown

    Insight

    Side-by-side input and output looked clear, but in testing users couldn’t tell what had changed. On payloads this long, modified lines blended in with everything else.

    Decision

    Mark what changed instead of making users compare. It’s easier to read than figure out what’s different.

    A payload with the modified lines highlighted rather than left for the reader to spot
    After: the changed lines are marked, so nobody has to diff two long payloads by eye.
  2. 02

    Definitions in place

    Insight

    Specialists encountered unfamiliar terms like “base config” with no way to look them up without leaving the page and losing context.

    Decision

    Bring the definition to the term instead of sending the reader to a glossary.

    An inline definition appearing beside an unfamiliar term, in place
    After: the definition comes to the term, so the reader never leaves the page.

Making the invisible visible

The shipped Log Inspector, listing every processing step a message passed through
Every step a message passed through, in order, on one screen.
A single step expanded, showing exactly what it changed
One step opened up, showing exactly what it changed.
The detailed code view for readers who want every transformation
The same step in full detail, for the readers who want the code.

Reflection

This project was a reminder that great design doesn’t happen in isolation. Engineering worked side by side with design to make sure we could visualize the invisible in a way that was both technically feasible and genuinely useful. Getting everyone aligned wasn’t always easy, but by the end we had turned a black box into a glass one.

The black box beside the glass box: the same pipeline, now with every step named and the failing one marked
The same steps, and the same message. The only thing that changed is that you can see inside.