Oluwatosin Kazeem

Running a caregiving agency is harder than it looks. Before ClaraWave, most agencies were managing caregivers, patients, and schedules through spreadsheets and manual processes. Payments were inconsistent and often missed deadlines. Matching caregivers to patients took time and guesswork. Onboarding new caregivers was done manually. Nothing was connected in one place.

ClaraWave is a multi-sided platform built for the US home care and disability support market, connecting three groups through one connected system.

Agencies use a web app to onboard caregivers, register patients, and manage day-to-day operations. Caregivers use a mobile app to view upcoming services, track payments, and download invoices. Patients use a mobile app to see scheduled services, receive invoices, and make payments.

An AI layer sits at the centre of the platform, helping agencies match the right caregiver to each patient based on preferences, availability, and compatibility. The platform also handles caregiver payments and payouts, calendar management, and real-time coordination across all three user groups.

As the sole designer on the project, I designed all three applications from scratch. Over eight to nine months, I worked closely with the development team to build a product that handles real complexity without making users feel it. On top of the product work, I also designed all the social media launch assets and the App Store and Play Store listings.

ClaraWave was a client and collaboration project through my company, GreyInvent. One of the product co-founders is a designer who played a big role in the visual direction. He created a document outlining the kind of style they were looking for, which helped reduce back-and-forth on interface direction and let me focus on the experience.

Before starting the design work, we studied existing platforms in the caregiving space: ShiftCare, WellSky, Axxess, and Caryfy.ai. I signed up for some of these platforms to see how they actually work, not just how they look. One of the things I noticed is that most healthcare platform designs feel dated, but I quickly realized that doesn't really matter. What matters is what works.

What I learned was what they do well and where the gaps are. ClaraWave aimed to differentiate through deeper AI integration across the board: AI-powered scheduling with fatigue prevention, real-time payroll automation, AI-driven Medicaid billing with fraud detection, auto claim denial handling with AI correction and resubmission, AI-powered on-demand shift matching, caregiver rating and performance scoring, and integrated Electronic Visit Verification. Most competitors had some of these features. None had all of them.

The research phase focused on competitive analysis, checking existing platforms to understand how things are currently done. The stakeholders were generous with sharing links to existing platforms during our initial alignment meeting, explaining what competitors do and don't do well, and how we planned to use those gaps to our advantage.

What I found confirmed the problem: agencies are still doing a lot of things manually. Spreadsheets for managing caregivers and clients. Manual caregiver-to-patient assignment. Manual payment processing, leading to missed deadlines and missed payments. All of this was what ClaraWave was designed to solve.

I created information architecture for the different modules and sent it back to stakeholders to confirm alignment before moving into design. For example, when assigning a caregiver to a patient, it can be done manually or automatically. There was a flow created for each path.

The project kicked off with an alignment meeting with stakeholders, developers, and the PM. The goal was to get everyone on the same page about the product vision.

After the meeting, I did my own competitive research, signing up for existing platforms to experience them firsthand. From that research, I mapped out what competitors do well and where they fall short, which fed into the information architecture.

Once the IA was approved by stakeholders, I created a style guide and component library before jumping into the actual interface design. This included tokens and reusable components. It wasn't a fully documented design system, but it served the same purpose: consistency across three modules so nothing feels disconnected. With three platforms being built simultaneously, this investment paid off immediately.

The PM set up tasks in Jira, broken down by module, which tracked every piece of progress. We designed all three modules in parallel rather than sequentially. This was a deliberate decision. Because the three apps are interwoven, an agency assigns a caregiver, the caregiver sees it on their app, and the patient sees the service on theirs, designing them together let us test end-to-end flows as we went.

I used a mix of wireframes and high-fidelity design depending on the flow. Some needed to be worked through at a lower fidelity first; others I could jump straight into high-fidelity.

Every Friday, we had a meeting with stakeholders to showcase progress and get feedback. This weekly cadence was essential given the tight timeline. When we reached about 60-70% completion, we started inviting potential agencies to see the platform. We called them, showed them what we'd built, and got feedback based on their current workflows and what would make things easier for them. This happened multiple times and was incredibly insightful. It gave the whole team confidence that we were building the right thing.

After the design work was done, I worked closely with developers to ensure pixel-perfect implementation. I used detailed annotations in Figma explaining the behaviour of every flow, and the dev team had access to Figma's dev tools. Testers on the team checked for bugs as we built, while I tracked design discrepancies. This continued through many iterations until we reached about 90% completion.

The agency web app is the most feature-rich of the three modules. Core features include AI-powered caregiver-to-patient matching based on preferences saved during onboarding such as language, location, availability, experience, and care type, automated payment processing for caregivers with configurable pay periods, automated email notifications for patient payment reminders, and AI integration throughout the platform.

The caregiver mobile app lets caregivers receive invites from agencies or download the app independently and request an invite if they believe they're a good fit. Their key views include upcoming services with patients, a calendar view, and a payment page showing upcoming payments with downloadable invoices for tax purposes. Caregivers set their own hourly rate.

The patient mobile app shows upcoming services with dates and a payment page for receiving and paying invoices. Given the age range of users, from elderly patients managing the app themselves to younger family members helping, I designed the patient app with larger font sizes for better accessibility.

One feature I'm particularly proud of is the geolocation check-in. A caregiver cannot sign in for a service start unless they are physically near the patient's location. This confirms to agencies that the service is actually starting when and where it should be. Transparency built into the product.

The scheduling system was designed to balance visibility without overwhelming users. We used a combination of in-app notifications and email notifications to surface what's important without creating notification fatigue.

For payments, the system is agency-driven. The platform automatically calculates payroll based on clocked time and completed tasks at the end of whatever pay period the agency has set. On the caregiver side, they set their own hourly rate, and the platform brings both sides together.

The hardest design problem was managing the complexity across all three modules without missing a feature or mixing things up. Even with proper PM support and Jira tasks, it was a challenge to keep everything straight. On the agency side specifically, the challenge was keeping the interface clean and light despite having the most functionality. The same tension existed across all three apps: lots of features, simple UI.

The payment flow on the agency app went through multiple iterations, as did the calendar view on the caregiver app. These were the most complex, high-stakes flows in the product.

Some features were scoped out of the MVP due to the tight timeline. The focus was on shipping a solid core experience first.

For cross-platform consistency, the style guide and component library kept things aligned across all three modules. Since the mobile apps used a single codebase, one repo for both iOS and Android, we maintained the same UI rather than splitting into platform-specific conventions. This was a practical decision driven by the development approach.

For error states, I made sure every error communicates what went wrong in plain language and offers a solution when there is one. In my experience, bad products are often bad because they can't communicate issues to users clearly. This was especially important in a caregiving context where users range from tech-savvy agency admins to elderly patients.

We also made changes to some of the language used in the design after user testing confirmed certain labels were confusing. The language needed to be simple and clear for all three user types.

I worked with the dev team through Figma annotations and dev tools. The design file was the source of truth, with detailed notes explaining flow behaviour at every point.

Feedback came through weekly Friday stakeholder reviews. This fast iteration loop, combined with the tight timeline, kept decisions moving and prevented bottlenecks.

There were moments where engineering constraints forced design rethinks. Some interactions had to be simplified when the original approach was too complex given the time we had. That's the reality of shipping on a deadline.

As the sole designer, I managed my time across the three platforms through Jira task tracking. The PM helped coordinate priorities, and designing all three modules in parallel rather than sequentially actually made the work more efficient since I could see how changes in one module affected the others.

I used Figma plugins to verify all text met WCAG accessibility standards. Beyond automated checks, I watched users interact with the app and confirmed they had no accessibility issues.

The product went into beta testing during my time on the project. The reception was positive, with good feedback particularly around the onboarding experience.

While I don't have specific metrics to share, the project delivered a complete three-module platform designed from scratch in under nine months.

Three fully designed applications, the agency web app, caregiver mobile app, and patient mobile app, shipped with a shared component system and consistent design language.

The final product included AI-powered caregiver-to-patient matching with fatigue prevention, automated payroll and billing flows replacing manual spreadsheet processes, geolocation-verified service check-ins for transparency, accessibility-tested interfaces with WCAG-compliant text, and social media launch assets plus App Store and Play Store listings.

The beta launched with positive feedback from stakeholders and potential agency users.

I'm proud of my ability to design this entirely from scratch as a solo designer and deliver all three modules within the timeline. The positive feedback from stakeholders confirmed we built something that solves real problems.

The biggest lesson I took from this project is that working in modules helps you debug faster and test end to end more effectively. Designing the three apps in parallel wasn't just a timeline decision. It was a better way to work on a multi-sided platform.

If I could change one thing, I'd swap the typeface. I was asked to use Inter, but I would have gone with Figtree.