All client communication in one app

01The problem

Small business owners run client communication across a phone dialer, a texting app, and an email inbox that never talk to each other. A quote goes out by email, the client texts back a question, and the follow-up call happens with none of that history in front of the owner. Context scatters, and the owner wants to stay on top of every client without becoming their own IT department.

This is a workflow problem, not a marketing one. A single client relationship spans three channels, multiple team members, and states like missed calls, unread texts, delivery failures, and voicemail. All of it had to live in one coherent thread on a small screen used on the move.

02My role

I was the lead product designer on GoTo and owned the mobile experience for iOS and Android end to end: the unified contact model, the combined thread, the composition flows for call, text, and email, and the empty, loading, and error states. I set the interaction patterns, drove the scoping decisions with the PM, and iterated the specs directly with the engineers building each channel.

03The approach

I ran short interviews with small business owners and rode along with GoTo's support team to see where existing setups broke down. The recurring signal: owners didn't think in channels, they thought in clients. That reframed the whole design. I organized everything around the contact and their unified thread rather than around three separate inboxes, which is where an early channel-first concept had started.

The competing constraint was scope. A full shared team inbox with assignment and internal notes was tempting, but SMS delivery, provisioning, and cross-channel threading were each non-trivial on mobile. I cut the team inbox from v1 and shipped single-owner threading first, so we could prove the core "one client, one thread" idea before taking on multi-user complexity.

I designed the system states deliberately: a first-run empty state that walks an owner through connecting their number, loading and send-in-progress states for slow mobile networks, and explicit failure states for undelivered texts and dropped calls. I checked contrast and hit targets and made sure every channel action was reachable and labeled for screen readers, since owners use this one-handed between jobs.

04What I built

I shipped the unified iOS and Android app: call, text, and email a client from one screen, with the full cross-channel history held together in a single thread instead of split across apps.

Working with engineering, threading email and SMS into one timeline was the hard constraint. The two channels have different identity and delivery models, so I designed the thread to degrade gracefully when a message's status was still pending or a channel wasn't yet connected, rather than blocking the view. That let engineering ship channels incrementally instead of waiting on a perfect unified backend, and kept the interface honest about what state each message was in.

05Outcome

The app launched on both platforms as the single place SMBs manage client communication. Owners told us the combined thread was the thing that finally let them stop switching apps mid-conversation, and support saw fewer "where did that message go" tickets once history lived in one place instead of scattered across a dialer, a texting app, and email.

The v1 cut came back as the clearest v2 driver: owners on teams kept asking who had already replied to a client. That direct feedback justified building the shared visibility I'd de-scoped. V2 added a team-aware thread so multiple people could see and pick up client conversations without stepping on each other.

06Reflectionoptional

Cutting the team inbox from v1 was right, since it let us validate unified threading fast, but I under-designed the seams for it. If I did it again I'd shape the v1 thread data model with multi-user in mind from day one, so the v2 team layer was a smaller lift instead of a partial rework.