Yoko ShiinaProduct Designer specialising in UX Architecture

A screen can look exactly as designed and still be frustrating to use.

Much of what people experience happens between the screens: when data is out of date, when a request fails, when someone needs a way back. How the product responds in those moments shapes how easy it is to use.

I’m a product designer specialising in UX architecture. I design the user experience and the system behaviour behind it together, bringing usability and technical feasibility into decisions about states, data flow, validation, error handling and messages before implementation begins. My software engineering background helps me work through these decisions with the people building the product.

Between design and codeTwo outlined frames, design on the left and code on the right. In the narrow space between them, a yellow band shows the elements of system behaviour that shape the user experience: state, data, validation, error and message.DesignCodestatedatavalidationerrormessage
States, data, validation, errors and messages all shape what people experience.

Work

Case study

Behaviour and data design for an energy operations dashboard

UX design for new features and improvements to an internal smart-city energy dashboard. I designed the user flows, states, data requirements, validation and error handling; worked with the back-end engineer to agree data and API responsibilities; and stayed involved through vendor implementation and release. The case study takes a closer look at two new features from this work.

Sample specification

Daily shift upload

One person replaces a full day’s shift data in a single action. The structure of the case study, rebuilt on a fictional shop, with a working screen.

Sample specification

Returns and refunds

Three roles handle a return over several days, and refund results arrive later. Screens in Figma, with the specification and API contract.

Sample specification

Museum guide

Visitors save works in the gallery without an account and look back at home, even after the exhibition ends. Screens in Figma, with the specification and API contract.

Software engineering — React, Next.js & TypeScript

Hands-on development across a startup MVP, financial SaaS, internal tools and my own applications. My experience includes feature development, shared UI components, API integration, testing, accessibility and maintaining existing codebases.

View experience

For more UI/UX design work, see myUI/UX design portfolio

When to bring me in

If any of these sounds familiar, parts of the experience may still need defining, even with clear requirements and finished screen designs. I've seen this in large, well-organised teams too.

  • The feature meets its requirements and matches the designs, yet people still find parts of it difficult to use.
  • The designs show the screens, while behaviour after a failed request, a timeout or a return visit, including how interactive elements respond, is still to be defined.
  • UX improvements are proposed in broad terms, with the decisions and concrete implementation tasks still to be worked out.
  • Engineers infer the data requirements and processing flows from the screen designs as they build.
  • Unexpected behaviour in existing screens leads to manual workarounds, and similar bugs or rework keep coming back.
  • When an error occurs, the screen says “Please contact support”, leaving users to resolve the issue through another channel.
  • Users pass on tips and warnings verbally to help one another avoid mistakes.
  • A feature with many states, error cases or data rules is about to be built.
  • Implementation is going to another team or an external supplier, who needs the intended behaviour and data requirements spelled out.

How I fit into your team

I work alongside your team. How I contribute depends on the team’s setup and where support is needed.

Your team

Small teams led by a CEO and CTO

How I contribute

I handle UX architecture and UI design, and can also help with front-end implementation when needed. I work with the CTO to align interface behaviour with data and API requirements. This means the CTO can spend less time on detailed UX decisions and more time on core technical work.

The experience depends on how the product behaves.

A brief can be clear and the interface carefully designed while important behaviour is still open: which states are possible, what needs to be validated, how data moves, what happens when something fails and how someone recovers. These are UX decisions, even when they first appear as implementation questions.

When those decisions are left until development, engineers must resolve them alongside deadlines, tests and existing code. Their technical choices can be sound, and the experience can still be confusing even when the screens match the designs and the tests pass.

Defining the intended behaviour in concrete terms, and including it in the implementation tasks, gives the team a shared basis for building and testing it.

I work with the people designing and building the product, bringing UX decisions together across design and engineering. My role adapts to the team and what the project needs.

Designing the experience and the behaviour together

This is the area of product design I specialise in: UX architecture. I look at how a product behaves as a working system alongside how its screens look, and bring what users are trying to do and the business rules together with interface states, data flow, validation, error handling and technical constraints. Where these pull in different directions, I work through the trade-offs in light of the project’s constraints, so that the experience and the behaviour fit together.

I define the data and API requirements behind the interface and can also contribute to their implementation. Where infrastructure or server-side work requires specialist expertise, I work with the engineers responsible. With the team, I agree how the interface behaves, what data it needs, how that data is exchanged and how responsibilities are divided across the system. The decisions and the reasons behind them go into a screen specification. When an interaction is easier to judge by using it, I may build a working prototype to test it.

Implementation choices are made by the engineers doing the work. My software engineering experience helps me identify which UX decisions need agreement beforehand and which questions are better settled during development. I can also contribute to implementation when the project calls for it.

What changes as a result

The main change is that important UX work, which might otherwise be settled during implementation under time pressure, becomes part of the agreed design and the implementation plan. This includes which errors need different handling, what users should be told and how they can recover and continue. With these behaviours defined, teams can plan the work, estimate the effort and test whether it has been implemented as intended.

Engineers can spend less time deciding what the user experience should be during implementation, and more time on how to build it. People using the product get clearer feedback, a better understanding of what has happened and a way to move forward.

The screen specification makes these easily overlooked UX decisions and the technical requirements they affect visible to the whole team. It provides a shared reference for carrying the intended experience through into the finished product.

Edge cases, decided and explained.

Here are five of the 35 cases in the shift upload sample. File validation has three outcomes: block the upload, ask for corrections, or apply the data with a request to check. The specification also covers connection, permission and edit-conflict cases.

SituationHandlingWhy
B6
The date in the file does not match the date selected on screen
BlockingEach upload replaces a whole day. If the dates do not match, the file could overwrite another day's schedule, with no way for the user to undo it in the screen.
S4
The day’s schedule has changed since it was loaded
BlockingComparing the version loaded on screen with the current version at save time prevents an outdated upload from overwriting newer changes.
A4
A current staff member has no row in the file
Needs correctionOff-duty staff still need a row. If a row is missing, the message identifies the staff member by name and ID so the user knows what to restore.
A17
Work is split across separate periods
Needs correctionEnough hours in total do not satisfy the rule of one continuous period of at least three hours. The message identifies the staff member and work periods so they can be corrected.
A12
A slot has nobody working
CheckSome periods may intentionally have nobody scheduled. The system saves the update, then warns and asks the user to check.

Open the shift upload sample

This sample uses a fictional business. I built the working screen alongside the specification to test its behaviour.

How a project works

I can get involved from the start of a new product or join an existing project at any stage. We agree on the scope and how we work together based on the needs of the project and the team. I work with the people the product is for and those building it.

I can also stay involved over several months or longer as the product evolves, defining new features, reviewing implementations and refining existing behaviour with the team.

  1. 1

    Listen. I start with the people who use the screens and the people who build them: what happens today, where it goes wrong, and what still has to be decided.

  2. 2

    Align and decide. I bring together what people need to do, the business rules and the technical constraints to define how the feature behaves: its states, validation, error handling, feedback and recovery. Where behaviour depends on back-end data or APIs, I work with the back-end engineer to agree what each screen needs, how data is exchanged and which side handles each check. I document the decisions and trade-offs in a screen specification. When an interaction is hard to judge on paper, I may build a working prototype to test and refine it.

  3. 3

    Hand over. The screen specification gives the team the agreed behaviour and the information needed to implement it: states, edge cases, validation, error codes and messages, data and API requirements, and the reasons behind key decisions. If some details are still open, I record them clearly rather than leaving engineers to infer them. Once the required data and API decisions are agreed, front-end development can begin based on the specification while the remaining back-end design is still in progress.

  4. 4

    Follow through. Where needed, I review code with the team to confirm that the implementation matches the specification and the intent behind it, and help resolve questions that arise during development. I can also contribute to implementation when the team needs hands-on support.

Experience

UX Architect

Internal operations dashboard, smart-city energy management

Designed the user flows, screen behaviour, data requirements, validation and error handling for new features and improvements to an energy operations dashboard. I also worked with the back-end engineer on data and API responsibilities and stayed involved through implementation and release. The case study above takes a closer look at two new features from this work.

Software Engineer

Play'n GO

Refactored legacy game code in TypeScript and Java for updates to an in-house UI framework, fixed bugs, and built features for an internal deployment tool. I also documented game-specific integration issues and brought the team together to define what engineers should check before QA. The resulting checklist became part of the normal development process.

Frontend Engineer

Startup for an online learning platform MVP

As the sole front-end engineer on a four-person team, I led the front-end architecture and implementation of a learning platform MVP using Next.js, React and TypeScript. I built user and admin interfaces, integrated login and course completion certificate issuing, designed behaviour for failed and interrupted processes, and worked with the CTO on data handling and API requirements.

Frontend Developer

LSEG TORA

Worked across two teams: developing and testing components for financial SaaS products, and building an internal PDF reporting MVP. In the product team, I improved a shared UI library and clarified interaction details where requirements were incomplete. For reporting, I classified existing report types through interviews and actual reports, then built a simple interface that generated PDFs in approximately 5–20 seconds during testing.

Web Developer & UX Consultant

Freelance

Worked on more than 20 websites, from end-to-end development for small businesses to information architecture and user-flow work on multilingual projects. For a beauty appliance manufacturer, I worked with the CEO to define the brand direction, rebuilt its corporate site and online store around buyers' questions, and created FAQs using recurring support enquiries. Corporate-site sessions rose 174% following the relaunch.

Account Strategist — Acquisition & Creative Direction

Recruit

Managed advertising for more than 35 salons while developing new business. I combined conversations with owners and staff, local observations and performance data to shape customer acquisition strategies, promotional offers, copy and photography. For one salon, I aligned the advertising with the owner's vision and raised the advertised coupon price. Monthly visits attributed to the advertising more than tripled, and the repeat-visit rate tripled.

Training and certifications

  • Microverse, full-stack software development programme
  • Certified ScrumMaster (CSM), Certified Scrum Product Owner (CSPO)
  • IAAP Certified Professional in Accessibility Core Competencies (CPACC)

About

Important decisions about how a product works are often still open when its screens look finished. What happens after an action, when a process fails, or when data changes? As a product designer specialising in UX architecture, I work through these questions before implementation, bringing together user needs, business rules and technical constraints to define how the experience should work.

The foundation of my approach is understanding both the user and the business. I began my career in advertising for hair salons, where I combined conversations with owners and staff, observations of the local area, trends and performance data to make decisions about customer acquisition and branding. I carried that approach into more than 20 website projects. For a beauty appliance manufacturer, I worked with the CEO to clarify the brand’s direction, then reshaped the website and product pages around the questions people had before buying. I also created FAQs based on questions the support team regularly received.

Working in software development brought another set of challenges into focus. Even in a financial SaaS team with detailed designs and thorough reviews, decisions about how features should behave did not always have a clear owner. On a startup MVP, I worked through behaviours that the designs had not covered, including failed processes and returning to an interrupted process, and implemented them myself. At a game company, I also helped resolve unclear responsibilities between development and QA by bringing the team together to agree on what needed to be checked before handover.

These experiences showed me that important decisions about product behaviour often emerge between design and implementation, even in well-organised teams. Engineers can make those decisions during development, but defining the intended behaviour earlier helps maintain a consistent user experience and reduces misunderstandings and rework.

More recently, I worked as a UX Architect on an energy operations dashboard, designing interactions, data handling and error behaviour based on the needs of the people using it. For example, I specified checks to prevent CSV data from being uploaded against the wrong date, and error messages that help users identify and correct problems themselves. I used Figma and working prototypes to develop requirements with stakeholders, documented the decisions in implementation specifications, and stayed involved through code reviews, implementation changes and the start of live operations.

My software engineering experience is also hands-on: I build and improve applications with TypeScript, React and Next.js, and can contribute to prototyping or implementation when a project needs it. My approach combines an understanding of how people think and act with practical knowledge of how software works. I care about the decisions beyond the screen design, and about making sure they work in the finished product.

I also have a background in accessibility. When relevant, I consider what screen readers announce when content changes and whether errors can be understood without relying on colour alone. I hold the IAAP CPACC certification, have written about accessible interfaces, and have built Contrastly, a tool for checking colour contrast.

Yoko Shiina

For interface and visual design work, see myUI/UX design portfolio

Writing and tools

Writing

All articles on Medium

Tools

  • Contrastly

    A colour contrast tool that brings Tailwind CSS, Radix Colors, Open Color, shadcn/ui themes and custom palettes into one workflow. It combines real-time WCAG checks with previews for text, UI controls, focus indicators, icons and data graphics, and supports design token import and export. A playful Liquid Colour Transfer animation sends a drop of colour from the selected swatch into the preview, where it spreads and settles with a gentle wobble. Keyboard interaction, screen reader feedback and reduced-motion behaviour are built into the experience, with accessibility tested using Playwright, axe and VoiceOver.

    Open the app

Contact

I take on UX architecture and interface design, separately or together, depending on what the project needs. Hands-on engineering support is also available where needed. I work asynchronously by default and am used to working with teams across European time zones. If you have a new product or feature you want to build, or something you want to improve, a few lines about the work and where you need help are enough to start.

yoko@solastudio.studio

LinkedIn