Layla — Web App from Scratch
Layla — Web App from Scratch
Built a data-heavy B2B SaaS web app from scratch for property operations, increasing customer satisfaction by 45%
Built a data-heavy B2B SaaS web app from scratch for property operations, increasing customer satisfaction by 45%
I designed Layla's web platform from scratch, from research to release: a data-heavy workspace where property managers run their entire portfolio. Within weeks, 60–70% of users adopted it, and sales went from 12 to 30+ closed deals a month.
I designed Layla's web platform from scratch, from research to release: a data-heavy workspace where property managers run their entire portfolio. Within weeks, 60–70% of users adopted it, and sales went from 12 to 30+ closed deals a month.
Web App
Web App
Data-heavy UI
Data-heavy UI
B2B SaaS
B2B SaaS
IoT
IoT

Overview
Overview
Role
Product Designer
Duration
1 year
Scope
Web App (0→1)
Team
Product, Engineering, Sales & Marketing
Layla is a B2B SaaS platform connected to IoT sensors, giving property managers real-time visibility into properties they can't always be on site for. Its users manage anywhere from 10 to 50+ properties at once: globally distributed, often under high operational load, and with mixed technical proficiency.
Until then, Layla only existed as a mobile app, built for quick check-ins on the go. But the deeper work of running a portfolio, like spotting patterns, reviewing history and reporting on incidents, happened at a desk, and the product had nowhere to do it.
I designed Layla's web platform from scratch: from research and information architecture to UI, the design system and release. Along the way, I worked closely with engineering to shape what we could build, and with sales and marketing to make the web app something they could confidently put in front of customers.
Layla is a B2B SaaS platform connected to IoT sensors, giving property managers real-time visibility into properties they can't always be physically present in. Its users manage anywhere from 10 to 50+ properties at once — global, distributed, and often under high operational load with mixed technical proficiency.
Over two years, I led UX research from the ground up, built the design system from scratch, and redesigned the mobile app end-to-end for both iOS and Android. Working with an IoT-based product also meant going deep into technical research — I read through extensive sensor documentation to fully understand device capabilities and unlock features that weren't yet being used in the product.
This required close, ongoing communication with both hardware and software engineering teams to translate technical constraints into a mobile experience that actually worked.
Impact
Impact
A brand-new platform that customers adopted fast and sales could build on.
A brand-new platform that customers adopted fast and sales could build on.
of users adopted the web app within the first weeks
more closed deals per month after launch
customer satisfaction (CSAT) after launch
The Opportunity
The Opportunity
The mobile app answered one question well: is everything okay right now? But property managers kept running into questions it couldn't answer:
Which properties have the most incidents this month?
Is this noise problem a one-off, or does it happen every weekend?
How do I document an incident for an owner or a guest?
These needed history, comparison and space, and a phone screen offered none of them.
The same gap held the business back. Sales was pitching Layla to property management companies running dozens of properties, but the product they could show was built for checking one property at a time. There was no way to demonstrate what Layla could do at portfolio scale.
That set the brief: a web platform built from scratch, where managers could see patterns across their whole portfolio, and that sales could confidently put in front of customers.
The mobile app answered one question well: is everything okay right now? But property managers kept running into questions it couldn't answer:
Which properties have the most incidents this month?
Is this noise problem a one-off, or does it happen every weekend?
How do I document an incident for an owner or a guest?
These needed history, comparison and space, and a phone screen offered none of them.
The same gap held the business back. Sales was pitching Layla to property management companies running dozens of properties, but the product they could show was built for checking one property at a time. There was no way to demonstrate what Layla could do at portfolio scale.
That set the brief: a web platform built from scratch, where managers could see patterns across their whole portfolio, and that sales could confidently put in front of customers.

Mobile for reacting in the moment, web for managing at portfolio scale
Research
Research
I didn't start the web app with a blank page. By then I'd already spent months with Layla's users: auditing the old app, reading through support tickets and reviews, and interviewing property managers who ran anywhere from 10 to 50+ properties.
Going in, the plan was simple: mobile-first for everything. But the more I listened, the clearer it became that this wasn't how managers actually worked. Their phone was for checking in between other things: a quick look in a taxi, a glance after an alert. The real thinking happened at their desk, with time to compare properties, look back at what happened last week, and figure out what to do about it.
That changed the plan. Instead of one app trying to do everything, we split the product in two: mobile for monitoring, web for management.
I didn't start the web app with a blank page. By then I'd already spent months with Layla's users: auditing the old app, reading through support tickets and reviews, and interviewing property managers who ran anywhere from 10 to 50+ properties.
Going in, the plan was simple: mobile-first for everything. But the more I listened, the clearer it became that this wasn't how managers actually worked. Their phone was for checking in between other things: a quick look in a taxi, a glance after an alert. The real thinking happened at their desk, with time to compare properties, look back at what happened last week, and figure out what to do about it.
That changed the plan. Instead of one app trying to do everything, we split the product in two: mobile for monitoring, web for management.

"How research reshaped product decisions" — before / after table
The insights from those interviews still held, they just looked different on a bigger screen. Managers still thought in urgency, not data, but now across their whole portfolio, not one property at a time. Raw numbers still meant little without context, but on desktop there was finally room to show history, so a manager could tell a one-off spike from a real pattern. And trust still came first: if they couldn't tell whether a sensor was online, nothing else on the screen mattered.
The insights from those interviews still held, they just looked different on a bigger screen. Managers still thought in urgency, not data, but now across their whole portfolio, not one property at a time. Raw numbers still meant little without context, but on desktop there was finally room to show history, so a manager could tell a one-off spike from a real pattern. And trust still came first: if they couldn't tell whether a sensor was online, nothing else on the screen mattered.
Information Architecture
Information Architecture
Starting from scratch meant there was no existing structure to work around, which was both freeing and a little scary. Before designing a single screen, I needed to answer a simpler question: how do property managers actually think about their work?
The answer turned out to be three levels: their portfolio, a property, and the sensors inside it. Everything in the web app follows that order, from the big picture down to the detail.
That became four main areas:
Dashboard — what needs attention across the whole portfolio
Properties — every property, its live status and everything about it
Insights — patterns and history over time
Settings — account, team and preferences
Inside each property, I kept things in one place with simple tabs: current data, sensors, users and notifications. Larger properties often have more than one sensor, so a switcher lets managers move between rooms without leaving the page.
A few patterns kept showing up across every interview:
Users think in urgency, not in data.
Nobody wanted to browse metrics. They wanted to know whether something needed them right now.
Scale changes everything.
What feels manageable with 3 properties breaks completely at 30. The app had to work for the busiest manager, not the average one.
Context beats raw values.
"75 dB" means nothing on its own. Users needed to know if a reading was normal, rising, or a problem.
Confidence matters more than completeness.
Managers didn't need every data point. They needed to trust that sensors were online and the data was live.

Information architecture: three levels, from the whole portfolio down to a single sensor
One decision shaped the whole product more than any other: grouping data by what it means, not by which sensor measured it. A manager dealing with a noisy guest doesn't care that noise and occupancy come from different readings; they want to know if the property is okay. So data lives in three groups that match how managers already think: Sustainability & Savings, Activity & Security, and Indoor Environment & Air Quality. The same groups appear on the property page, in Insights and on mobile, so once you learn them, you know your way around everywhere.
One decision shaped the whole product more than any other: grouping data by what it means, not by which sensor measured it. A manager dealing with a noisy guest doesn't care that noise and occupancy come from different readings; they want to know if the property is okay. So data lives in three groups that match how managers already think: Sustainability & Savings, Activity & Security, and Indoor Environment & Air Quality. The same groups appear on the property page, in Insights and on mobile, so once you learn them, you know your way around everywhere.
The Solution
I wanted the web app to give managers the depth mobile couldn't, without bringing back the clutter we'd just worked so hard to remove. So every core screen is built around one question a manager asks when they sit down at their desk.
Dashboard
"Where are the problems across my portfolio?"
The dashboard opens with incidents, grouped by type: noise, temperature, carbon monoxide. Each card shows the total, but the real value is underneath: a ranked list of the properties with the most incidents. A manager doesn't just see that there were 24 noise incidents last month; they see that five of them happened at the same property, and that's where they should look first.
A simple time filter lets them switch between what happened today and longer-term patterns. Savings are still there, but below, as context rather than the headline.
I wanted the web app to give managers the depth mobile couldn't, without bringing back the clutter we'd just worked so hard to remove. So every core screen is built around one question a manager asks when they sit down at their desk.
Dashboard
"Where are the problems across my portfolio?"
The dashboard opens with incidents, grouped by type: noise, temperature, carbon monoxide. Each card shows the total, but the real value is underneath: a ranked list of the properties with the most incidents. A manager doesn't just see that there were 24 noise incidents last month; they see that five of them happened at the same property, and that's where they should look first.
A simple time filter lets them switch between what happened today and longer-term patterns. Savings are still there, but below, as context rather than the headline.

Dashboard screen
Property Overview
"Is this property okay, and if not, what's wrong?"
This is where managers spend most of their time, so it had to answer that question in seconds. The header comes first: is the sensor online, when did it last update, what's the temperature and humidity. If the data can't be trusted, nothing else matters.
Below, every reading tells a story instead of just showing a number. Noise isn't "78 dB", it sounds like a loud party, with a chart showing how it built up over the evening. Occupancy isn't a raw count, it's medium risk, around 3–4 people. And when an alarm goes off, the card says what happened, when, and what to do next: verify the activity or dismiss it.
Property List: see what's wrong without opening anything
Goal: Help managers scan their portfolio and instantly tell which properties need action and which ones are fine.
The legacy list showed identical cards with the same row of numbers, so managers had to open every property to find a problem.
Online/offline status on every property, with "online first" sorting
Sensor types shown as a consistent, scannable row
Designed to stay readable at 30+ properties, not just 3

Property List Screen
Insights
"Is this a one-off, or a pattern?"
Insights is the part of Layla that only made sense on desktop. Managers can pick a property, a sensor and a time range, and see how noise, motion, occupancy or air quality changed over days or weeks. Threshold lines make it obvious when something crossed into risk.
From there, they can generate an incident report or export the data, which turned out to be exactly what managers needed when they had to document a problem for an owner or a guest.
Property Overview: is everything okay here?
Goal: Answer one question instantly: is everything okay in this property right now, and if not, what needs my attention?
Clear separation between real-time data and historical stats (tabs)
Status visibility: online/offline and "updated 1 min ago"
Metrics reframed in user language with visual cues
Progressive disclosure to reduce cognitive load

Property Overview Screen
Design System
Design System
Layla's design system was built to serve both mobile and web from day one. But the web app was where it really got tested: dense, data-heavy screens asked for things the mobile app never had to.
Tokens that carry meaning
Everything starts with color primitives: grey, orange, red, yellow and green scales. On top of them sit semantic tokens, and that layer is what made the system work for Layla. Status colors like success, warning, attention and error aren't just colors, they're how managers tell "act now" from "back to normal" at a glance. Defining them once meant an alert looks and feels the same whether it shows up on a phone or a 27-inch screen.
Layla's design system was built to serve both mobile and web from day one. But the web app was where it really got tested: dense, data-heavy screens asked for things the mobile app never had to.
Tokens that carry meaning
Everything starts with color primitives: grey, orange, red, yellow and green scales. On top of them sit semantic tokens, and that layer is what made the system work for Layla. Status colors like success, warning, attention and error aren't just colors, they're how managers tell "act now" from "back to normal" at a glance. Defining them once meant an alert looks and feels the same whether it shows up on a phone or a 27-inch screen.

Color system: primitive palettes mapped to semantic tokens for content and feedback states

Button component library: primary and secondary variants across sizes, icon placements and interaction states
One type system, two scales
Work Sans runs through both platforms, with a full scale from large headings to small overlines. Desktop and mobile each get their own sizes, so the hierarchy holds up whether a manager is scanning a dashboard on a laptop or checking an alert on the go.
One type system, two scales
Work Sans runs through both platforms, with a full scale from large headings to small overlines. Desktop and mobile each get their own sizes, so the hierarchy holds up whether a manager is scanning a dashboard on a laptop or checking an alert on the go.

Type scale: Work Sans hierarchy from H1 to Overline, with decoration variants and synced text styles
Components for dense screens
Beyond the basics like buttons, text fields with every state, switches, chips and steppers, the web app needed components built for data: cards with charts and plain-language summaries, gauges for signal quality, and toasts for warnings, successes and errors. Each one was designed to work across both platforms, so building a new screen on web rarely meant starting from zero.
Components for dense screens
Beyond the basics like buttons, text fields with every state, switches, chips and steppers, the web app needed components built for data: cards with charts and plain-language summaries, gauges for signal quality, and toasts for warnings, successes and errors. Each one was designed to work across both platforms, so building a new screen on web rarely meant starting from zero.

Core components: text fields, buttons, selection controls, stepper and toasts with all their states
XFN Collaboration
The web app wasn't just a tool for property managers; half the company ended up depending on it. That meant designing it with every team, not just handing screens over to engineering at the end.
Product & leadership
I brought research into every roadmap conversation, so decisions about scope and priorities started from what managers actually needed. When things got complex, my job was to turn that complexity into a few clear options the team could decide on.
Engineering
Since we were building from zero, I worked with the developers from the very beginning to check what was feasible before I got attached to any idea. Prototypes did a lot of the talking here: walking through a flow together was the fastest way to catch edge cases and agree on how things should behave.
Sales & operations
This is where the web app made the biggest difference. Sales used my designs and prototypes in demos and pitches long before launch, and they brought back feedback straight from customers, which went right back into the design.
Marketing
Marketing and I made sure the story about the product was the same everywhere, from the app itself to launch visuals and messaging. Together, we positioned the web app as something competitors didn't have.
The mobile app touched almost every team at Layla: product leadership, engineering, hardware and sales, each with different priorities. A big part of my job was getting them into the same conversation.
Learning the hardware first
I hadn't worked on a hardware-dependent product before, and I quickly realised I couldn't design good experiences without understanding how the sensor actually behaved in the real world: its limitations, failure modes and how reliable its data was.
So I went beyond the documentation:
I set up sessions with the hardware and engineering teams
I asked to see real sensor logs, error cases and edge conditions
I tested the sensor myself to feel the setup friction and failure states first-hand
That let me translate technical constraints into UX patterns and clear system feedback. A reading like "78 dB" tells a manager nothing. "Sounds like a loud party" tells them exactly what's happening. The same thinking shaped how I designed onboarding, alerts and troubleshooting flows.

The prototype behind the redesign: every flow connected and clickable, so the team could test it before a line of code was written.
Trade-offs
Trade-offs
Building from scratch meant every decision closed a door somewhere else. These were the ones I thought about the most.
Depth vs. clarity
Desktop gave us room to show far more data, and some users asked for exactly that: more numbers, more charts, everything at once. I held back. Every screen still leads with status and a plain-language summary, and the deeper analysis lives in Insights, where managers go when they actually want it. We lost a bit of "everything in one place", but kept a product any manager could read in seconds.
Feeling like one product vs. feeling native to desktop
Reusing the card style from mobile made the two apps feel like one, but cards take up more space than a dense table would. I kept them for the property page, where context matters most, and switched to compact ranked lists where scanning many properties mattered more, like inside the dashboard cards.
Shipping sooner vs. shipping everything[What did you leave out of the first release?] We launched with the core: dashboard, properties and insights. That meant some requests had to wait, but it got the web app into customers' and sales' hands faster, and that early adoption is a big part of why it worked.
Every decision that made the app clearer for one group took something away from another. These were the ones that mattered most.
Urgency over savings
The old dashboard led with energy savings, CO₂ and trees saved: numbers the business was proud of and that supported Layla's eco positioning. Research showed managers didn't open the app for that. I moved incidents to the top and savings below. We gave up some brand storytelling on the main screen in exchange for a dashboard people could actually act on.
Plain language over precision
"Sounds like a loud party" is easier to act on than "78 dB", but it hides detail some users want. Instead of choosing one, I led with the human-readable status and kept the raw value as secondary information, one tap away.
One critical event, not all of them
Showing every event on a property card would have made the list complete, but unreadable at 30+ properties. I chose to show only the latest critical event per card. Managers get a fast overview; the full history lives inside the property.
Mobile for monitoring, web for management
Keeping mobile focused meant some power users couldn't do everything from their phone. We accepted that, because trying to fit every management task into mobile would have brought back the clutter we were removing.
"Last updated" instead of true real-time
Engineering flagged that live, second-by-second data wasn't realistic with the sensor's reporting intervals and performance limits. Rather than pretend otherwise, I designed clear "updated X min ago" timestamps and online/offline states. Less impressive than "live", but honest, and it built the trust managers told us they needed.
Learnings
Learnings
Real workflows matter more than feature completeness.
Layla's sensors could measure a lot, and it would have been easy to put all of it on screen. What made the web app work was building it around what managers actually do at their desk, not around everything the hardware could do.
Design works best as a shared language.
The biggest shifts on this project didn't come from a single great screen. They came from moments when engineering, sales and marketing could look at the same prototype and talk about the same scenario. That did more for alignment than any meeting.
Iteration isn't a sign of failure.
Some of the best parts of the web app came from things we got wrong first and fixed after testing with real users. On a product this complex, that's not a detour, it's how it gets good.
Understand the system before designing the interface.
Working on an IoT product taught me that the most important design decisions often come from outside Figma: sensor logs, hardware limits, how data actually arrives. Learning the technical side early saved us from designing things that could never work reliably.
Start with what's broken, not with the brief.
"Redesign the app" could have meant a fresh coat of paint. Digging into tickets, reviews and interviews first turned it into a clear problem: people didn't know what needed their attention. Everything else followed from that.
Design is a shared language.
The biggest shifts happened when engineering, sales and product could see the same prototype and talk about the same scenario. Making decisions visible did more for alignment than any argument could.
What I'd do next
Toward the end of my time at Layla, the company started selling sensors directly to consumers on Amazon. That would change the app's biggest challenge: from helping managers prioritise many properties to helping a first-time homeowner set up a single device on their own. Self-serve onboarding and even clearer, plain-language data would be where I'd start

Key Learnings: What I learned in the this project