Yoko ShiinaCase study

Behaviour and data design for an energy operations dashboard

I worked on UX design for new features and improvements to an internal dashboard for smart-city energy operations. This case study focuses on two new features from that work: operation planning and operation mode switching. The work had previously relied on Excel, CSV files, commands entered by hand and direct database updates. I defined the behaviour and data flow for the new screens before implementation, agreed the data and validation boundaries with engineering, and handed the specification to an external vendor. I stayed involved through implementation, and both features were released and are now in operational use.

Role
UX Architect
Context
Internal operations dashboard, smart-city energy management
Worked with
Operations staff, managers using the screens, engineering, external implementation vendor
Outcome
Both features released to production and in operational use

Company names and some figures are withheld for confidentiality

What was undecided

The new features let operations staff create and apply short-term or experimental operation plans for power equipment. A wrong plan could affect operating costs and supply stability: power supply could be interrupted, or equipment might not charge as needed for the next day.

Plans are uploaded as CSV files, and each upload replaces the selected day's data as a snapshot. Anything missing from the file can be treated as deleted. The relationship between what the user does, how the file is validated and how the data is updated had to be defined with care.

A similar app used elsewhere in the same business showed why this mattered. The boundary between days, especially at midnight, was unclear, and mistakes were frequent. Users had to remind each other what to watch out for. Errors could say only "There is an error. Please contact the person in charge", show a bare code, or show nothing. People could not tell how to fix problems themselves, and the app eventually fell out of use.

My reading of the cause: a manager asks for a feature and an engineer builds it as requested. Neither is wrong, but no one clearly owns the decisions between the request and the implementation. This project had no designer or project manager. That conversation was my work.

Some requirements could not be decided without seeing concrete behaviour. The scale also had to be planned for: around six devices at first release, and 50 to 100 devices across 48 half-hour slots later.

How the decisions were reached

I put concrete screens in front of the people who would use them and worked through the requirements with them. Some decisions were hard to make in the abstract, so I used mockups to test requests before committing them to the specification.

  1. Listened

    I asked the operations staff how they built and applied plans across Excel, CSV, the command line and database updates. I mapped the steps, the effect of each data update, the risks, and what users needed to decide for themselves.

  2. Proposed

    I first proposed a daily view with one card per device. Each card had its own registration status, 48 inputs, and save, duplicate and delete actions.

    Early daily view with one card per device, each with inputs for every half-hour slot
    Draft 1: One card per deviceEach device as its own card, with a registration status, inputs for each slot, and save, duplicate and delete actions.
  3. Reworked

    With 50 to 100 devices across 48 slots expected, one card per device would not give a useful overview. I split the interface into a month view, showing two months at a glance and which days have plans, and a day view for detailed work. I changed the day view to a table.

    Two-month grid showing which days have plans for each device
    Draft 2.5: Month gridTwo months side by side, showing which days have plans. Days can be selected for bulk deletion, or opened in the day view.
    Day view as a single table of devices and half-hour slots
    Draft 3: Day tableThe move from cards to a single table, to handle the number of devices and slots in one view.
  4. Refined

    I worked through editing states, bulk operations, data updates and safeguards against operating errors before finalising the specification. In the final version, devices became rows in both views. As columns, every added device would widen the screen; as rows, the layout can accommodate more devices without getting wider.

    Day view in edit mode with pending changes, bulk deletion and a note on pasting from a spreadsheet
    Draft 4: Editing and bulk actionsOn-screen editing, explored on request and moved to the next release. Edit mode, pending changes before saving, bulk deletion by row and column, and pasting from a spreadsheet. Slots within five minutes of their start, and past dates, cannot be edited.

I did not treat Figma and code as separate design and build stages. Figma suited comparing structure and layout. Code suited testing data volume and the effect of an operation. I moved between them depending on the question.

Decided before implementation

The date in the file must match the date on screen.

Uploads can start only from the selected day's view, and a file with a different date is blocked. Slips will happen: tomorrow's file can end up on today's page. Wrong content under the right date can be replaced with a corrected upload. A wrong date is harder to recover from, because it becomes unclear what was registered where. I discussed this safeguard with engineering, and we agreed on it early in the project.

Errors that stop the upload, and errors the user can fix.

I listed every case I could foresee before deciding how each should be handled. The front end checks file type and size, date mismatches, dates outside the permitted range, missing slots among the 48, invalid device IDs, inactive devices and values above each device's limit. When processing cannot continue, the upload stops. Data errors the user can correct are grouped together with their row and column, so they can be reviewed and fixed in one pass. I defined how each validation result and processing failure changes the screen.

What an error says.

The back end returns error codes, and the front end shows the message mapped to each one, in English and Japanese. The aim is that users understand what happened and can fix it on the spot, and that what the back end means and what the screen shows do not drift apart.

Destructive and operationally significant actions.

Deleting a single day and deleting several days at once are separate actions. Before a deletion or a change of operation mode, a confirmation shows what will be affected and the operational impact. Users can control when an uploaded plan takes effect.

Where data lives.

I defined where each kind of data would live — on the server, temporarily on the front end, in Context or managed in application state — and what should happen as data moved between them.

Data and API responsibilities.

I identified the data each screen needs and when it needs it, proposed candidate structures, and discussed with engineering which side should handle each transformation, weighing efficiency, consistency, reusability and safety. The validation boundary between front end and back end was agreed in the same way. The final API design stayed with the back-end engineer, and I wrote the agreed behaviour, endpoints, payloads, responses, validation boundary and error codes into the specification.

Scope.

Users asked to import spreadsheets directly and wanted to keep their own records and calculations there. I chose CSV for import: it was straightforward to export from a spreadsheet, validate and turn back into a table. Later, users also asked to edit directly on screen and paste as they would in a spreadsheet. Material UI did not provide that behaviour out of the box, so I built a working mockup, including copy and paste (Draft 4). When the remaining deadline became two weeks, there was not enough time to deliver both approaches with the external vendor and back-end dependencies. I separated essentials from nice-to-haves, kept CSV for this release and moved on-screen editing to the next. The decision weighed implementation cost, existing ways of working, data constraints and the risk of operating errors.

Left to engineering

How the screens were built stayed with the engineers: conditional logic, component structure and props, nesting, how state and effects are implemented, and code that stays consistent with existing pages and is easy to extend and read. I defined what appears and when, where data goes, how validation is split, and what the messages say.

When decisions about behaviour are left until coding, implementation details can end up determining the user experience by default. Settling those decisions first lets engineers concentrate on how to build. I included the wording too, so the intended behaviour and messages were clear.

Handed over

Where behaviour was hard to judge from a document, I tested it in a working prototype built in the project's own stack: React, Next.js, TypeScript, Material UI and MSW. It covered CSV parsing, validation, selection states, error handling, destructive actions and data volume on the existing codebase, which brought technical constraints into the decisions early. It was shared with the vendor as supporting material, and part of its code was reused in production.

Carried through implementation

I reviewed the vendor's code against the agreed behaviour, validation, error handling and data flow, and checked its effect on existing screens. Where a review comment alone would not make the fix clear, I included sample code showing a safe implementation. I also implemented or corrected parts that were incomplete, complex or differed from the specification, and those changes went into production. I used GitHub Copilot to help identify possible bugs, validation gaps and security concerns, checked each finding against the actual code and context, and fixed the issues I confirmed.

Result

Screens

Annotated specification for the operation planning month view
Operation planning: month view.Two months at a glance, showing which devices have plans on which days. Template download and bulk deletion of selected days start here, and selecting a day opens the day view.
Annotated specification for the operation planning day view
Operation planning: day view.Devices against 48 half-hour slots for the selected day, with CSV upload, download, validation and deletion. This is the only place uploads can start.
CSV validation errors listed with row, column and cause
CSV validation result.Correctable errors are grouped with their row, column and cause, so users can review several issues in one pass. Errors that stop processing never reach this point.
Operation mode and status controls, before and after a change
Operation mode switching.The current mode is shown, and users control when uploaded plans become active.
Confirmation shown before applying an operation mode change
Operation mode switching: confirmation.The current state and the state after the change, side by side, before anything is applied.

The shift upload sample

The design for this project is confidential, so I rebuilt the same structure on a subject that can be shown publicly. The snapshot replacement and the decisions that follow from it are kept as they were.

This projectShift upload sample
Devices × 48 slotsStaff × 8 one-hour slots
Month and day views of operation plansMonth and day views of a shift schedule
Daily snapshot replacement by CSVDaily snapshot replacement by CSV
Inactive device IDsIDs of staff who have left
Minimum and maximum output per deviceOne continuous work period of at least three hours per staff member, with no split shifts
Operation mode switchingSwitching a schedule between draft and published
A wrong plan affects power supplyA wrong schedule affects people's actual shifts

Open the shift upload sample

Try the screen. Validation runs, and the relevant part of the specification appears alongside it.

Open