<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Akhil Dakinedi on Medium]]></title>
        <description><![CDATA[Stories by Akhil Dakinedi on Medium]]></description>
        <link>https://medium.com/@a_kill_?source=rss-5af7cde87b09------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*DkjLDtNs17LMpqQpx5yK_g.jpeg</url>
            <title>Stories by Akhil Dakinedi on Medium</title>
            <link>https://medium.com/@a_kill_?source=rss-5af7cde87b09------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 07:02:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@a_kill_/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[DoorDash Visions: Redesigning the Dasher app’s homescreen]]></title>
            <link>https://medium.com/@a_kill_/doordash-visions-redesigning-the-dasher-apps-homescreen-f40d1b09ba8c?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/f40d1b09ba8c</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Sun, 16 Nov 2025 00:38:57 GMT</pubDate>
            <atom:updated>2025-11-16T00:38:57.288Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AMUoDT4L13o4aValc_x0lA.png" /></figure><h3>The Dasher app</h3><p>The Dasher team at DoorDash works on the Dasher app that gig workers use every day to make deliveries through DoorDash. <strong>1.8 million Dashers open this app every day to go online, receive offers, pick up your food, navigate to your house, and drop it off at your door. </strong>The Dasher app is the link between a restaurant receiving your order and it arriving on your doorstep some time later. More importantly, it’s the <strong>financial lifeline for all the gig workers who rely on the app to make ends meet and keep the lights on</strong> by completing deliveries on-time and at a high level of quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k39V_WaKA1C7N2x_KowD1Q.gif" /><figcaption>The main flow Dashers use every day to complete deliveries on DoorDash (as of early 2024). The app is the guiding tool and primary interface that Dashers interact with to figure out where to go, what to do, and which steps to follow in order to complete their deliveries and earn income through DoorDash.</figcaption></figure><p>Let’s say a Dasher has some spare time on a Thursday evening and wants to check if they can earn some extra income through DoorDash. The first thing they would do here is open the Dasher app to see if it’s a good time to earn that money. They would see that it’s busy with lots of offers in their area (“busy” in this context is a positive term in that it’s “busy with offers”), and they would then go online by hitting the <em>Dash now</em> button, which puts them in an online mode where they start receiving offers that they can choose to accept or decline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6KHI1tmpyM_Qu7dtTVa1Iw.png" /><figcaption>The homescreen of popular gig economy apps (as of 2024) typically show drivers some information about what it’s like in the area they’re in and have one primary action to enter an “online” mode to receive earning opportunities. The homescreen is the first view that drivers see when they open the app, and it’s a critical surface in which drivers make decisions when, where, and how to earn. The Dasher app’s homescreen felt more complex and cluttered than its competitors.</figcaption></figure><p>This case study deep dives specifically into the homescreen and how we redesigned it. I primarily worked with my rockstar design partner Ruolan Xia and our Design Director Samiksha Kothari on an end-to-end redesign of the Dasher app’s homescreen, but there were several other designers and Product partners that I collaborated with throughout the design and build phases that went on for well over a year. You’ll get to see our design process, approach, strategy, and the whole messy middle of the creative process when it comes to <strong>a redesign whose ambition ballooned in scale over the months, along with how we struggled to scope it down to shippable milestones in small chunks</strong> to ensure it got into the hands of our Dashers and didn’t just fizzle out in a vision deck.</p><h3>I: Background</h3><p>If DoorDash’s goal is to get Dashers on the road to fulfill deliveries, the the <strong>goal of the Dasher app’s homescreen sounds simple enough:</strong> <strong>tell people whether or not there are deliveries out there right now that need to be fulfilled.</strong><em> </em>And yet, the design of the homescreen didn’t quite reflect this. It lacked an opinionated point of view and <strong>didn’t help Dashers make decisions about the best times to dash.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zkKeaOYiCFsdA2AFJrxToQ.gif" /><figcaption>As dashing grew in complexity, our homescreen didn’t scale to keep up with it. What started out as a simple homescreen quickly got cluttered with additional entry points, new features, and additional CTAs due to a lack of ownership and governance of the homescreen.</figcaption></figure><p>DoorDash’s business had significantly evolved in just the last five years alone, and making deliveries on DoorDash got even more complicated than before. Teams needed to ship features quickly about different ways to earn, tell Dashers about new incentives, show the cheapest place to fill up gas nearby, or change your vehicle from a car to an e-bike. Since there wasn’t any “owner” of the homescreen surface, it became the <strong>de-facto dumping ground for these features because it guaranteed impressions and visibility every time someone opened the app. Over time, the homescreen lost its focus on dashing as the core action that the screen needed to drive.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g6LZvMxzNDDWojgGkk4_rg.png" /><figcaption>A breakdown of all the elements on the homescreen and the % of Dashers that interact with them in a given week. Not all the entry points on the homescreen were being used frequently. Some were accessed so rarely that they didn’t warrant such a prominent placement on the homescreen with a persistent entry point that was always visible. Note: % data shown above is a rough approximation based on averages in one area in one week.</figcaption></figure><p>We started by looking at all the buttons on the screen today — <strong>what are they, why do they exist, and how frequently are the used?</strong> This was a strong starting point for us to start thinking about which buttons we could remove or de-emphasize on the homescreen (based on current usage). It also hit home for me just how strange and complicated some of the things we have on here are —<strong> we were providing Dashers with way too many things to do here but we really just wanted them to hit the <em>Dash now</em> button.</strong></p><p>While we were working with our Analytics team to pull this data, we also asked Dashers in interviews about how they used the homescreen. This was very revealing, as it turns out most Dashers were looking for key information like <strong>how much they can expect to earn </strong>and <strong>how busy they will be on their dash,</strong> none of which the homescreen was doing a good job of conveying.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zfBTJiz1jmKIoT20ZZkIjg.png" /><figcaption>A small sampling of the types of things Dashers told us in research interviews. Many of these directly influenced the design ideation and informed the path forward. These were eye-opening for me &amp; the rest of the team to understand the large gap between what Dashers actually wanted to see on the homescreen and what we actually showed today. It re-inforced without a doubt, to the entire team, that the homescreen desperately needed a redesign.</figcaption></figure><p>Armed with all the data and user insights, we ran a one-week long design sprint with our cross-functional team in our official kickoff for this project. Product Managers, User Researchers, Engineering Leads, and Data Analysts all joined the designers for a brainstorming session where we talked through the problems as we know it today and we the traditional design sprint activities to generate ideas. <strong>Having our XFN partners looped in from the very start was critical in ensuring that everyone felt they had a voice in the redesign</strong>. They also had a lot more business context and knew the constraints we’d need to operate in really well, which helped a lot in filtering the ideas to get to a good starting point.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mje0xpEOcEY5wSkMoiC1Jw.png" /><figcaption>Our weeklong design sprint dived deep into our Supply &amp; Demand marketplace to inform the business strategies we were developing with the redesign of the homescreen. Involving all of our key cross-functional partners ensured that everyone felt involved in the design process from the very start.</figcaption></figure><p>A theme that quickly developed in the design sprint was that we needed a fundamentally <strong>different strategy on how to address a market that was <em>undersupplied</em> vs. one that was <em>oversupplied</em></strong>. In DoorDash terms, an <em>undersupplied</em> market is one where the number of Dashers out on the road (the supply) is lesser than the number of outstanding orders that needed to be fulfilled (the demand). The inverse applies for the <em>oversupplied market</em>, where there’s so many Dashers on the road that any new Dashers opening the app get blocked from dashing completely. A lot of the ideas that came up focused on a better way to schedule future dashes and providing alternative earnings opportunities for those Dashers blocked from dashing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Od6pNBDRlAdD3cNKuLT97A.png" /><figcaption>Some quick examples of various ways to organize the information architecture I was exploring in the design sprint. The solution space was massive given the amount of potential information we could communicate to Dashers, and it took some repeated iteration to get to something that felt clear and simple.</figcaption></figure><p>We quickly hacked together a concept prototype to test with Dashers, which forced us to make decisions quickly. Unlike other gig apps, Dashers can only make deliveries in certain zones (due to food spoiling or going bad otherwise for long drives), so we used this constraint to our advantage to create a framework where we leaned on the map to let Dashers decide <em>where </em>to dash, use the two-state bottom sheet to help Dashers figure out <em>when </em>to dash (now or later), and leverage the earnings calculator concept to educate Dashers on <em>how </em>to dash (i.e., how they’d like to earn).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ibNRv5jTpoGJbf9rnvpfDg.gif" /><figcaption>The concept we put together and tested at the end of the design sprint has two different modes, one where a Dasher is able to dash now and another focused on scheduling a dash for later. Our “Earnings calculator” idea let the Dasher choose between Offer Mode (where they earn a set rate on every offer) vs. Time Mode (where they get paid hourly for the time spent when on an active delivery)</figcaption></figure><p>On the last day of the design sprint, we ran concept testing sessions with Dashers to test this prototype. Some of them understood it and others were completely thrown off by the change. We learned some key things from this concept test:</p><ul><li>We’re asking Dashers to make <strong>too many decisions </strong>(dash now or later, in which mode, and where)</li><li>It’s intimidating to see <strong>so many numbers and controls</strong> on-screen</li><li>Showing some predictive indicator of <strong>how much they will earn is helpful as long as we can actually guarantee it</strong> (which isn’t always true)</li><li>Dashers liked seeing additional information like a <strong>busyness forecast</strong> for the rest of the day on-screen, as it helps them plan their day</li><li>Dashers wanted better control and choice over what <strong>types of offers</strong> they would get on their dash (ex: pizza, alcohol, grocery, etc.)</li></ul><p>In just one week of the design sprint, we went from having no strategy to a clear path forward on what to work on in the coming weeks. We knew it would be a lot of design iteration, so we rolled up our sleeves and dove in.</p><h3>II: Early design direction</h3><h4>Information architecture &amp; navigation</h4><p>Now that we had a better sense of what Dashers needed from this view and what the problem space really was, we began the design process by trying to figure out what the new IA of the homescreen should be. I started by looking at how Dashers made decisions about staring their dash on the screen today to inform how we think about restructuring the IA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fVkByXU_GjVgsgu8bkX6aQ.png" /><figcaption>How Dashers make decisions today about whether or not to dash. Many Dashers prefer staying in their “home” zone due to the familiarity of streets, traffic patterns, and restaurants, but those with more time who are willing to drive further out do venture into neighboring zones to complete deliveries.</figcaption></figure><p>Concurrently, we were also exploring ways to simplify the UX and layout of the concepts we had from the design sprint to see if there was a way to <strong>keep the homescreen focused and simplified while continuing to iterate on the things that Dashers said they liked</strong>. There were a <em>lot </em>of components to play with on this screen, and the four of us (all designers) were working in the same Figma file building on top of each others’ explorations from the design sprint to keep pushing the design forward towards one unified vision. It was messy and chaotic with us often going in circles or working on older versions of each others’ work-in-progress designs, but it forced us to make decisions quickly and align on a path forward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zblah16njmh0t5ISNNvPRw.png" /><figcaption>UI explorations &amp; refinements coming out of the design sprint to ideate on the types of IA we could have, what components &amp; variations we could need in the homescreen, and how we would communicate and sequence critical vs. “good to know” information. There was a lot we needed to rank, categorize, and prioritize.</figcaption></figure><p>This exercise was helpful in revealing that there are a <em>lot</em> of things Dashers could do before starting their dash, and <strong>we needed to develop a point of view what the most important or best thing for them to be doing was</strong>. I started putting together a rough structure for the new information architecture in the bottom sheet to convey the most important information at the top while the less relevant information related to scheduling or viewing promos for planning a dash later were at the bottom. I tried to find a place for the best ideas coming out of the design sprint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RX1oi5vmSUAmP3wgj3qPuA.png" /><figcaption>Work-in-progress iterations for the information architecture of the bottom sheet specifically and how it could host a variety of content on scroll based on Dasher intent as well as what questions it’s answering for Dashers. I wanted to get to a solution where most Dashers can just hit “Dash now” and move on but those who were interested in further insights would have to scroll to find out detailed information</figcaption></figure><p>Our research interviews helped solidify what Dashers <em>really</em> needed from the homescreen, and we wanted to simplify the overall IA of the screen down to the bare basics. We wanted to go back to first principles and rethink this screen from the ground up:<strong> if all our features didn’t exist today, what would the ideal information architecture look like?</strong> To me, it felt like it would be a view that was focused first on dashing and displaying earnings front and center, while actions like Preferences and important communications in the Inbox would be accessible as secondary actions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x0I9Fpp-ooUKXfG0j2WDfA.png" /><figcaption>The new IA I was proposing to visually simplify the view and move all content into contextual modules in the bottom sheet. This also incorporates some research learnings around being able to access Preferences from this view and focusing the view on information related to dashing.</figcaption></figure><p>All of the other options that are <em>not </em>core intents would move to the new side menu or be absorbed into one of many existing surfaces of the app where it made the most sense. We also realized that those other screens needed a redesign themselves, and this is where we tried to limit our scope to just the homescreen and not propose a major overhaul of the entire app as part of this project (with mixed results, more on this later).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dhs6bBCWUNx_SCvRGdOcvA.png" /><figcaption>The proposed “side menu” with all the actions not related to dashing organized in there. The existing homescreen was also fragmented across the iOS &amp; Android platforms, so this was an attempt to unify both of them with similar navigational IA and hierarchy.</figcaption></figure><p>The new IA of the screen worked well with the bottom sheet’s IA structure. Now that the bottom tab bar had gone and all the items had moved to the side menu, the<strong> homescreen managed to stay focused on just the map and the bottom sheet</strong>. We stress-tested it with a 1:1 translation of our existing features along with some new ideas and the overall idea seemed to be working. The framework scaled well to many use cases and we were feeling good about future-proofing the design against upcoming incentives, insights, and trends. There was a place for everything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SFA_Lp4R50udbDlYVQ76ZQ.png" /><figcaption>Bringing it together with the high-fidelity options for the bottom sheet, it started to feel like we had something good here. We could control the height of the bottom sheet to keep the view simple and focused about information related to dashing, and when the user intent changes to explore more information about the zone or to schedule a dash for later, they could scroll on the view to see additional details</figcaption></figure><p>We had to make some tough calls around moving certain features out of the homescreen and into other parts of the experience. The Preferences screen in particular was a natural fit for any dash-related setting, and our proposal was to put everything that Dashers don’t frequently need to change before every dash in there. Preferences started to become a “dash settings” page where all the power user controls for dashing would live permanently, but we’d surface these contextually on the main homescreen as a small snapshot view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vovOKWukY1EtZWWc8OWUrw.png" /><figcaption>This is where scope creep really started to set in. In order to move all the controls and options Dashers could change out of the homescreen, we had to put then somewhere else. We resisted the urge to fully redesign these screens and just add the controls in there to see what it would feel like.</figcaption></figure><p>This was a really solid start to de-cluttering much of the UI in the homescreen, as it allowed more room for focusing on the design of the core intents. We tested this new IA in another concept testing round to ensure that the new locations for moved features are still discoverable and intuitive for most Dashers to cement our own conviction in this new IA.</p><h4>The map</h4><p>Given that it’s the most visually prominent piece of the homescreen and it’s the primary surface that Dashers interact with to select <em>where</em> to dash, we knew the map needed a complete overhaul. We worked with our Design Systems partner Matthew Burg to redefine the visual style of our map with the goal of having it be <strong>simpler, more fluid, and contextual to zoom levels.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gS1NJTd9gOrkyAe3Vfb14A.gif" /><figcaption>We defined brand new visual assets for the map to make it feel lightweight and easy on the eyes. We didn’t want to show the boundary of every zone if it wasn’t highlighted, and wanted smoother interactions between switching from one zone to another. Pins, zones, boundaries, and busyness iconography got a full upgrade.</figcaption></figure><p>We defined a <strong>1:1 relationship of the map to the content of the bottom sheet in the IA, where the sheet below always displayed information relevant only to that zone. </strong>One big pain point in the existing map is that it was not dynamic enough — it did not scale well with zoom levels that were too far out or when it was zoomed too far in. It felt like it was designed for the medium zoom level for viewing zones from a very specific distance, which we really wanted to address with this redesign.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pq7kJsWphz54W0RHuZgp5g.gif" /><figcaption>The interaction design for the map was important to nail down. We explored and defined several interaction patterns for pan, drag, and zoom gestures to make the map feel more responsive, dynamic, and contextual.</figcaption></figure><p>This was also a good opportunity to rethink the fundamental product assumptions on the map. Dashers wanted to know whether it was busy or not, but we were displaying 3 different tiers of busyness, including a <em>Very Busy </em>one which Dashers didn’t trust (according to our research). So we proposed <strong>simplifying this down to two levels of busyness: Not Busy and Busy, </strong>which matched the Dasher’s mental model of busyness better.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mwjcmi8OJEzXySteiJfVMg.png" /><figcaption>Stress-testing our new map design across the various busyness states, online state, and dark mode. We pushed for simplicity in every state and defined how every UI element animates, displays over content underneath, and animates to draw attention to critical state changes. Designs by Matthew Burg.</figcaption></figure><p>The visual upgrade on the map was massive. What was before a “sea of red” and visual noise turned into something that was now elegant and minimalist, only <strong>providing important information and gracefully scaling to zoom levels or any gestural interactions.</strong> This was the biggest difference in the old homescreen when compared against the new simply due to the fact that the components were brand new and looked visually distinctive with their own unique identity.</p><h4>Comms framework</h4><p>A big part of this project that I haven’t mentioned till now is the communications we send to Dashers on the homescreen. <strong>The old homescreen was the wild west, where any and every banner popped up due to the fact that it guaranteed impressions. </strong>Again, the lack of governance on this surface contributed to the mounting problem of modals, tooltips, banners, and UI elements crowding the screen to the point where the map was borderline unusable in some of the states.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xzyDljFR37LfIBnyGK6Xlw.png" /><figcaption>Actual screenshots of various banners, tooltips, and modals that could trigger on the homescreen before our redesign. It was unscalable, messy, and rendered the map and homescreen UI elements completely unusable in some instances. These screenshots alone were enough to make a case for our homescreen redesign.</figcaption></figure><p>Tackling this challenge itself was somewhat of an intimidating nightmare. My design partner Ruolan Xia took on the mammoth task of auditing the existing homescreen for every single banner, modal, bottom sheet, prompt, toast, or informational surface that popped up to see the range of possibilities. In total, we found over 150+ of these UI elements that could be layered on top of the homescreen based on some conditional trigger. What made it doubly challenging is that <strong>there was no system of ranking or priority logic to these comms, resulting in many duplicated or irrelevant comms shown to Dashers on top of other comms. </strong>All of this meant that we had to define a brand new system to figure out how to prioritize these.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Y9GVUg74oVdELfjw3AC8Q.png" /><figcaption>A new Comms Platform that we defined for all messages sent to Dashers, where the critical P0 comms that don’t allow the Dasher to dash (like account deactivations, or an in-progress background check) can take over the homescreen UI but comms categorized as P1 that influence decision-making about dashing can utilize one of two surfaces on the homescreen. Everything else that doesn’t require immediate action and is a “good to know” type of message gets marked as P2 and displays in the new unified Inbox</figcaption></figure><p>We decided on a strict template model where every existing and new comm would have to be categorized into one of 3 buckets and would need to be redesigned to fit into those. On top of that, there would need to be a ranking and categorization layer which sequences which comm is shown based on whether or not the Dasher has already seen it. As part of this process, we also found ourselves <strong>questioning if we needed these many comms to Dashers and took the opportunity to align with our Product team to kill or remove some 30% of them entirely </strong>while making design upgrades to the ones we needed to keep. The work on the comms alone deserves an entire case study to itself given how much work it was — it was all also being done concurrently as we were making design changes and decisions for the main homescreen.</p><h4>Concept testing</h4><p>After all this, we ran another round of concept testing sessions with Dashers to see how they felt about our redesign. I went in with low expectations here given that it such a huge change in the design. I fully expected everyone to hate it or be totally confused by it. But I was glad to be proven wrong — most of the stuff in the new design was working well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jAAaDTq-KGh_PvoSae6sVA.gif" /><figcaption>The design direction we tested (undersupplied state shown) to see if Dashers would understand the new IA, structure, and information. We were also playing with an idea for an “Earnings carousel” that would host a variety of earnings-related information inside of the pill in a snapshot view to get Dasher reactions.</figcaption></figure><p>The key things we learned here were:</p><ol><li><strong>Dashers <em>loved </em>the graph forecast</strong> and many even called out, unprompted, that it would help them be strategic with their time</li><li>The new <strong>Earnings pill </strong>also performed really well, with many Dashers calling out that they would find it motivational to see it there. However, the “Earnings carousel” was confusing to interact with given the density and variety of information displayed in there</li><li>A lot of Dashers were confused with where many of the options that used to be on the homescreen had now moved to (this was expected, given that there was no education about this). Many called out that they <strong>would like quick access to Preferences</strong> before starting their dash</li></ol><p>A huge shout out to our incredible researcher Sarah McCurdy for getting us all the right insights here and informing the next stage of designs.</p><h3>III: Sweating the details</h3><h4>Ruthless refinement</h4><p>We took the feedback from Dashers and started to figure out the next phase of work. We were doing daily reviews with our design leads to discuss what was working and what wasn’t. After much rigorous debate about the feedback, we landed on two core areas to focus on:</p><ol><li><strong>Brand differentiation: </strong>it’s great that we have a solid point of view on the IA and navigation, but what differentiates the Dasher app from other gig economy apps? What makes it <em>feel</em> like DoorDash?</li><li><strong>Limit the options:</strong> Our patterns of allowing a fully scrollable bottom sheet and new comms patterns opens the floodgates for other internal teams to continue shipping comms the same way they have been before. How can we enforce strict governance in the design itself to <em>make sure that we don’t end up with the same problems we have today</em>?</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w4T2Yj-xAYspB0l5h7zs7w.png" /><figcaption>We rapidly explored several iterations for typography, button styles, and UI components to try and push the bar for visual differentiation in the redesign. While the UX maintained the IA of other gig apps to stick with a consistent mental model, the UI was truly the place where we could infuse new brand and visual elements to differentiate ourselves and build an emotional connection to our product.</figcaption></figure><p>This phase of the design work involved a lot of iteration on the pieces we felt were working. The four designers (including myself) were working on separate pieces of the UI to <strong>push the visual design towards something that felt branded and differentiated </strong>while also ensuring that the insights from concept testing were addressed. There were many ideas for evolving the visual language of the Dasher brand we explored that we ended up not using, but it was a worthwhile exercise to make sure we had exhausted as many options as possible in the solution space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zAR1FpzqI2CilEwboE6wFw.png" /><figcaption>Stress testing our new visual elements across our dash journey was very revealing. Our primary action felt nice and strong with a bold icon, but there were some accessibility issues with having a button label outside the button itself. We also ran into a scaling issue with the icon on the right of the footer that would change from Schedule to Preferences when going online, which may feel awkward. Finally, there was too much going on visually with colors, type pairings, and elevations. The explorations helped a lot in developing a point of view. We continued refining and taking the best pieces of it forward.</figcaption></figure><p>I liked where this was going. We were defining new interaction patterns and themes for the homescreen that felt unique and different from the rest of the app. Our new theme &amp; styling for the components like the graph and primary button also had a bit more personality to them, which helped set us apart from other products. But the visual noise generated by the new designs was a bit much. As we started simplifying it, we realized that this <strong>project was now scope creeping into becoming a full on rebranding exercise for the Dasher app. </strong>We had to force ourselves to shift gears a bit and focus just on the homescreen first, so we started getting laser-focusing on our homescreen IA to get stricter about truly simplifying it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*akouFm2BKwCq6lLeMCvcKw.png" /><figcaption>A new IA that I defined based on the feedback to keep the screen extremely focused and simple. We enforced a hard constraint to limit the bottom sheet to just two pieces of information: the headline and the motivational content below. We would simply override the motivational content by replacing it with whichever piece of information was most relevant to Dashers at that time.</figcaption></figure><p>While similar to the original IA, the key differences in the new one was that the menu and secondary action were easier to reach with your thumb. It eliminated the need to reach farther up and tap buttons on the far top of the screen. Moving the buttons away from the top also <strong>gave the Earnings pill a bit more focus, which helped give it this “center stage” feel. </strong>We also decided here to have our map-related controls be shown closer to the map in order to reflect map changes in real-time instead of toggling a setting on in a menu buried deep within some settings menu and needing to navigate back to the homescreen to see the visual change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cQ6dv_nepbI12Ka8W3StTA.png" /><figcaption>Scaling our new IA across the offline, online, and offer states. This is the point where we started to feel like we were getting to a simplified, unique, and visually differentiated design. The bold typography and limited UI elements allowed by our IA started to let the screens breathe and feel lighter. We even scaled our primary button to turn into a “Pause dash” function in the online state which had a running timer for how long you had been dashing.</figcaption></figure><p>This new design was getting really close to our vision of a focused and simple Dasher homescreen, but playing with a prototype of it and reviewing it internally amongst designers and our team brought up a lot of good pieces of feedback. The top 3 things we wanted to address going forward were:</p><ol><li><strong>The placement of the menu </strong>being at the bottom-left in our design was a problem. The menu is accessible from all on-a-dash screens and it’s accessed from the top-left in those views (those screens didn’t have a bottom navigation to host a menu icon); we wanted to have a consistent and predictable place to open the menu from across the entire app</li><li><strong>The button on the bottom-right of the footer</strong> felt like it was switching too often between actions like Schedule and Preferences; the concept of a “smart action” that could switch to other options sounded good in theory but kept confusing Dashers in concept testing sessions</li><li><strong>The visual design </strong>still felt like it was all over the place, in that there were too many text styles being used and there wasn’t a strong design rationale for the excessive use of shadows, gradients, and elevations on our UI components, so we saved this for a rebranding workshop later</li></ol><p>We spent another two weeks addressing these elements to land on our final northstar design vision.</p><h4>The true northstar</h4><p>Going deep into the visual design rabbit hole, playing with the prototype, and diving into the details of each feature helped us <strong>develop a strong point of view about the best Dasher experience</strong>. Taking everything we had learned, I proposed that we structure the IA around three core Dasher intents on the homescreen:</p><ol><li><strong>Dash now</strong> (in <em>undersupplied markets </em>where Dashers can dash)</li><li><strong>Dash later </strong>(in <em>oversupplied markets</em> experience where Dashers are blocked from dashing)</li><li><strong>Check earnings </strong>(showing earnings more prominently on the homescreen)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*55TYyXRN42QESGdRsno-yw.png" /><figcaption>Our final IA mapping for the homescreen, where we moved the menu back to the top to align better with our on-a-dash-flows and changed the secondary action in the footer from Preferences to Schedule. This IA is almost exactly the same as the first version of the design we started with. Design iteration is often circular, and it was important to exhaust the alternative possibilities of what it could be. The key difference in the bottom sheet here is that it isn’t scrollable and is strictly limited to just showing a set number of content in there.</figcaption></figure><p>As we continued ideating, we consolidated our explorations into one design. Many of the ideas steered us back towards the original IA &amp; navigation. The menu worked best at the top-left simply because that’s also where it’s accessed from in all the on-a-dash flows. Our design now looked visually similar to the one we had before but with a <strong>much more focused point of view in how much information is displayed at once.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gMbcYl-zHhSaIZ-_xEBqCQ.png" /><figcaption>Our IA for the bottom sheet included a strict rule to not have it be scrollable but instead limit the UI component to only show actionable content and a visual module that supported the intended action that the message was trying to drive. Having it scrollable would lead to a slippery slope of every team internally adding more and more information based on what’s performing best, leading to the same information overload problem we had today.</figcaption></figure><p>Our final bottom sheet would <em>not</em> be a scrollable view but would instead be strictly limited to a a handful of components. The idea was to<strong> force the teams shipping features into the Dasher app to question the relationship of their feature to making a decision about dashing</strong>. If it was more important than deciding whether or not to dash in that moment, they could switch out the entire bottom sheet with a custom one. If it wasn’t, they would have to put the feature elsewhere. This forcing function would <strong>govern how information is displayed in the bottom sheet in order to keep it focused on decisions related to dashing</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iLRr3T0u-3ZD427nEoetVg.png" /><figcaption>Our final northstar designs with everything coming together that scaled across various states that the homesceen could be in. The “visual module” would be related to the action that the content in the bottom sheet is trying to drive — examples could be some infographic states, a graph that represents peak busy times, a progress bar for a streak, or some type of estimated earnings display. These were conceptual examples to showcase a range of possibilities.</figcaption></figure><p>This time, we stress tested extensively to ensure that our design worked across all use cases, even the online state. Seeing the same <strong>bottom sheet scale to nearly every single use case of the homescreen and beyond reinforced our confidence that this was the right path forward. </strong>In the back of our minds, we started defining the conditional logic that would trigger the state change from one to another. What changes in supply, types of offers, or motivational incentives would be the most appropriate to create a module for and display to Dashers on the homescreen? The framework would enable experimentation with various levers to test out what drove dash conversion and what didn’t.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mac4gdaLW9-RVI_p-gg0-Q.png" /><figcaption>Stress-testing our bottom sheet IA framework and module design to ensure that it worked with all the different states that the homescreen would eventually scale to, including Dasher onboarding as well as going online, navigating to hotspots, and accepting offers. This stress test built our own conviction that this was working well and was the right path forward. It managed to keep the focus on the core intents of dashing while maintaining simplicity and focus across all the screens. All the content design was still a work-in-progress at this point as we were defining the content strategy alongside the design.</figcaption></figure><p><strong>I compare cleaning up the homescreen of an app to tidying up your living room when you expect to have guests over. </strong>If your living room has a bunch of random books, clothes, used dishes, and pet toys lying around and you only have ten minutes to clean everything up, you would simply move that stuff out of the living room and into the bedrooms, cabinets, or closets just to get it out of the living room and have the space you expect your guests to spend the majority of their time in feel organized and put-together. For us, this meant moving everything that’s not related to dashing into our side menu. But we didn’t want it to feel like any other boring navigational menu, so one popular idea we had was to theme it based on tier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GPBtLzzd6xaUGp60YUNUFg.png" /><figcaption>Design stress testing for how our side menu could be themed based on the Dasher’s reward tier. Showing the name and tier in the side menu reinforced a sense of context and personalization that the app severely lacked before. We wanted it to feel sleek and focused because Dashers will be opening the menu frequently to navigate to other parts of the app. This side menu would be accessible from the online state and all on-a-dash screens as well, so some of the entry points like Earnings and Schedule are duplicated from the homescreen in the menu.</figcaption></figure><p>I also took this opportunity of consolidating “similar” settings that were scattered across our app into one unified place. We had Preferences, App settings, Dash settings, Map settings, Pay settings, and so many more options spread out randomly across the entire app. I wanted to merge all of these into one global Preferences page that would host all the various dash-related settings. I also didn’t want it to feel overwhelming, so I tried out a minimalist approach with contextual modules that conveyed the concept with the least amount of text.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*33eoaeO6qpm_uj11S9DfXQ.gif" /><figcaption>My Preferences concept where all dash-related settings could be hosted in one contextual view. The modules would expand or collapse as needed to show detailed information. Over time, Dashers would build up muscle memory of how to quickly toggle things on or off before starting their dash.</figcaption></figure><p>My Preferences redesign was inspired in part by the iOS Control Center, which hosts an array of complex features but manages to represent them in a visually simplified manner while ensuring that the interaction to toggle things on or off is fast and seamless. That’s our goal with Preferences as well, where Dashers can<strong> quickly turn something on or off without getting bogged down by the detailed explanation of each feature.</strong> So many of the options Dashers have today could be set to a “smart default” or behave in a way that is built into the dashing experience itself instead. For example, set the default dash length to two hours (which is the length of time that most Dashers said they dash for at a time) and let them change it in Preferences if needed. Better yet, offer an option to automatically take Dashers offline if it gets less busy, which Dashers have told us they would love.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sf3Jv4phzrN0UCREXVNQ2w.png" /><figcaption>The Preferences screen would scale to become a “Dash settings” screen when online. The “Dash for” block would expand to reveal dash-related settings where Dashers can pause, end, or extend dashes. Most Preferences cannot be changed in the middle of a dash, and the beauty of the modular design ensures that any future Preferences that we add that can be changed in the middle of a dash can simply be inserted as modules into the existing view.</figcaption></figure><p>I spent way too much time at this stage of the design process <strong>ensuring that every little feature and function could be rethought or redesigned in a different way to make the experience of interacting with it seamless and delightful</strong>. We proposed that we merge many of the similar functions into the same view and significantly uplevel our outdated UIs for planning future dashes. The really tricky part about designing these experiences in particular is that they are accessible outside the homescreen as well, which meant that I had to also stress-test them against all use cases where they could be accessed when on-a-dash.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DyFJ1XKhbGeFu8M4dj3ZfA.gif" /><figcaption>Our new “Map Controls” button would host all map-related settings, along with a brand new way to toggle to entirely different states of the map. Our existing feature that let Dashers view nearby gas stations to compare the cheapest prices was a natural fit for this. In the future, this could scale to show EV charging stations, parking spots, bikeshare locations, and much more.</figcaption></figure><p>The scope of the project by this point was basically redesigning half of the entire Dasher app — everything that you could access when you were not on a dash. We knew in the back of our minds that it was unlikely that all of these screens would be built as part of the homescreen redesign, but it was a worthwhile exercise to <strong>stress test our new visual language and UI components </strong>across these views. We were already deep in the zone of “<em>What’s the best version of this feature?</em>” anyway, so it wasn’t too much extra work to basically redo a bunch of features around our point of view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-2-apkFpLlJGUaqROQSlg.png" /><figcaption>Something that had always bothered me in our app was that Scheduling and Promos were two entirely separate screens, but both served a similar purpose to Dashers where they indicate good times in the future to dash. This concept combines both of those experiences in a “dash planning” view that allows Dashers to toggle between viewing upcoming scheduling slots and upcoming promos to decide when to dash.</figcaption></figure><p>One thing we kept hearing from other designers and teams is that they didn’t feel like there was a surface where we could communicate new features and actions to Dashers on the homescreen. With our simplification approach, we had taken away most of the collars, top sheets, and modals that we normally used to communicate critical information to Dashers. So we defined <strong>a new framework for opt-in nudges</strong> that could override the content of the homescreen in specific instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uvUt-eQngimSU5yHfFIm_Q.png" /><figcaption>When it wasn’t busy in their zone, Dashers would see options that would allow them to get busier. There are situations where an area has a high demand for alcohol deliveries but a Dasher hasn’t been qualified to do alcohol deliveries, so we’d nudge them to get qualified in these states.</figcaption></figure><p>These opt-in nudges could scale to any type of new offering that would trigger at a relevant time, like when it’s not busy in their area overall but it is busy for specific types of offers. This allowed <strong>a solution to always have something for Dashers to do</strong> when it’s not busy in their area instead of them just closing the app and leaving. Bit by bit, we defined a full set of components with guidelines on when to and when not to use them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CtiwUxF5IDJm30z_-JN69w.gif" /><figcaption>Splash screens were another huge opportunity to infuse branded elements when opening the app. It’s a versatile surface that can quickly convey the state of the area before diving deeper into the details on the homescreen. We wanted to ensure a smooth transition from any branded splash screen into the homescreen in the future. Splash screen designs &amp; transitions by Ruolan Xia.</figcaption></figure><p>We had thoroughly explored nearly every single screen, transition, state change, and had stress tested the homescreen to all use cases we could think of. With the support of our design leads, we had literally hundreds of conversations with several other teams internally to get them on board with <strong>what we were changing, why we were changing it, and what the future would look like.</strong> This simply took a lot of time and effort to make happen as we were finalizing the design — all of our mocks and animations were instrumental in conveying the exciting changes coming to the homescreen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lhh6sm4qp4vZ50uRR1u_xw.gif" /><figcaption>The final homescreen design when opening the app, going online, and finding an offer. This was the ultimate vision that we pitched internally to get everyone on board with the idea of opening the app and getting to your first earnings opportunity all in the same surface.</figcaption></figure><p>Besides this, we explored several under-the-hood systems changes to how our service actually functions. Our research sessions uncovered so many pain points and confusing things for Dashers on the existing homescreen that required fundamental investments in our core platform. This project was being used as a kickstarter to invest in large-scale changes to our app quality and started to become a posterchild for a design with an extremely high bar for quality and craft.</p><h4>Governance &amp; guidelines</h4><p>Remember the audit I had mentioned above that had 150+ comms to Dashers on the homescreen? We had to now tackle how to handle those in the new homescreen. My design partner-in-crime Ruolan created set templates for each type of communication and we defined what the new design should be like for every single thing on the homescreen. <strong>There’s no shortcut to this work aside from just sitting down and doing it</strong>, and it required a lot of back-and-forth conversations with our Product team about why the certain comms existed, whether or not we really needed them, and where else we could move it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*elaANvjigiPJkvCg2bAo_g.png" /><figcaption>The final templates for any message to Dashers on the homescreen. We took a hard stance to not have any banners, collars, or tooltips pop up in the view and limit the types of communications to just four surfaces. They were all defined based on their relationship to dashing. For example, the home sheet override could only be used if it blocked Dashers from dashing. The fullscreen takeover would be used when a critical account status change that blocked Dashers from dashing (but with access to the rest of the app). The bottom sheet was a good fallback for any remaining comms and it could be displayed at any height. Finally, the Inbox could host all the temporary bottom sheets with a permanent home that can be re-used for educational surfaces and informational content.</figcaption></figure><p>Once defined, our guidance was for teams to migrate their existing comms to one of these templates. This was a very strict rule where the comms <em>had </em>to follow these guidelines, or else it wouldn’t work with the homescreen redesign. <strong>The hardest part about this was enforcing these guidelines and making sure that teams stick to it. </strong>To add to the drama, there was a lot of in-flight work that was shipping which got stuck in this weird place of “<em>Should we wait for this redesign to ship first, or should we just ship our tooltip in the existing homescreen?</em>” for a while.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ik9LpT7nMABxV4yhcy2VtA.png" /><figcaption>The difference in before &amp; after is night and day. We moved all the banners &amp; tooltips to the Inbox, which already cleared up a ton of clutter on the homescreen. For things that were breaking the existing card on the homescreen like multiple stacking incentives, we chose the most motivational incentive and put the rest in the Inbox. We really didn’t want anything to get in the way of you and the Dash button unless it was absolutely critical. These strict guidelines combined with our IA change to remove unneeded elements from the homescreen completely transformed the view into a simple, delightful, and focused experience.</figcaption></figure><p>Finally, we had some governance on how to use the comms and some do’s &amp; dont’s on the homescreen as well. We were happy with how well our new design scaled to hundreds of use cases across dozens of features and various states that Dashers can end up in. We knew this was a massive step up from what we had before and significantly upleveled the Dasher experience, transforming it from an archaic and messy design to an elegant and thoughtfully crafted one.</p><p>We then attended a gauntlet of internal design crits, design reviews, product reviews, executive reviews, and all-hands presentations for what felt like months where I was just making slide decks upon slide decks, all with minor variations for different audiences. Once leadership and our team was aligned on the vision and path forward, the question quickly turned to resourcing and timelines. <strong>How were we planning to ship such a big, ambitious redesign? What were our milestones, and how long would each one take? </strong>There was an overwhelming sense of “<em>Are we actually going to do this?</em>” across our Engineering team, and we rolled up our sleeves yet again to break this beast down into shippable chunks, which was a whole adventure in itself.</p><h3>IV: Cupcakes &amp; chaos</h3><h4>Scoping the cupcake</h4><p>At DoorDash, our product development philosophy revolves around the affectionately termed <em>cupcake</em>. The idea is that <strong>if you were a bakery that specialized in wedding cakes and a customer walked walked through your door to get an idea of your product, what you would give them is a small sample of the type of delicacies you provide.</strong> This wouldn’t be an entire wedding cake or not even a slice of it. It would instead be a sized-down, mini version of your wedding cake that represents your quality, care, and attention-to-detail when it comes to the bread, frosting, cherry on top, packaging, service, and presentation — <strong>a cupcake.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X-xZ__akqa86Jhc81n-M4w.png" /><figcaption>The “MVP” product development philosophy at DoorDash, by <a href="https://helenaseo.medium.com/">Helena Seo</a></figcaption></figure><p>Too often, big tech orgs think of MVPs as <strong>a list of features that are simply above the cut line and are “must-haves” to deliver just enough value to a customer.</strong> If you baked your cupcake this way, you would end up with a list of ingredients that you’re simply hoping will come together in some sort of delicious and enjoyable treat. Would you really sell this to a customer? A true cupcake is one that is <strong>carefully crafted and shaped with just the right amount of everything, is set to bake for just the right amount of time, and is topped off with garnish to add that extra delight. </strong>This is what will win your customers and entice them to order your wedding cake.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8FBHyGmHTV6Oe9BSBvAnBg.png" /><figcaption>The components that make up a cupcake isn’t something that a bakery would sell individually</figcaption></figure><p>So we took everything we had in our vision (the wedding cake) and started chipping away at it to shape what the cupcake would be. And this was no easy feat. The redesign involved an app navigation &amp; IA change, a full restructuring of the homescreen, and completely redoing several other experiences in the app. <strong>We had to be extremely aggressive here to figure out how we could still deliver something delightful as the first milestone of this redesign.</strong></p><p>We got together with our Product &amp; Engineering leads and started debating how to tackle this beast. We spent several hours in a large conference room walking through the designs, listing out what all the big pieces were, and separating out the work into chunks to see what could be done in parallel. <strong>I want to underscore how important this process is, the decisions made in this moment inform the direction of the project for months and years to come</strong>. There will be heated debates and high emotions, but it’s worth working through it all to make sure you get to a shippable first milestone that lives up to the bar you set for quality and craft.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*peKpMZKE2EjM5u5lr-nS2Q.png" /><figcaption>We listed out all the big chunks of work we would need to tackle in order to break this project down into chunks to design and build. This is a really critical moment in the project because your ability to break down a vision into smaller pieces is the difference between a vision getting built or fizzling out due to a lack of clarity.</figcaption></figure><p><strong>As the design lead for the vision, it’s important to lead with conviction here.</strong> I got questioned about every single design decision, why we chose to do it that way, and why we couldn’t do it in a way that’s simpler to build. Thankfully, the months of rigorous debates we had internally within the design team had prepared me well to handle these concerns and back up the design decisions with confidence. After a few days of back-and-forth, we landed on these key decisions to scope the cupcake:</p><ol><li>We would <strong>couple the redesign with a rewrite of the app’s architecture and language</strong> (from UIKit to Swift on iOS and from XML to Compose on Android), accelerating dev velocity to make changes on the scale of days instead of weeks</li><li>We would <strong>start with just the homescreen as the cupcake</strong>, and descope the online state and all other designs to later milestones</li><li>We would <strong>build out an entire Comms Platform</strong> to host and migrate all the tooltips, banners, and messages we currently send on the homescreen. This was a critical piece of the redesign</li><li>We would <strong>not touch the map in the cupcake,</strong> as the designs in the vision require a broader change to the Map SDK and we were in the middle of migrating map vendors</li><li>We would target an <strong>internal employee test milestone that would launch within six months</strong>, even if building out the cupcake takes longer. This was important for team morale in what would be a long slog to build out the entire cupcake with a redesign and a rewrite</li></ol><h4>Building the cupcake</h4><p>Now that we knew roughly what shape the cupcake would take, we had to actually design the scoped-down version of the vision and spec what we’d be shipping in the first milestone. This involved figuring out <strong>how to create the UI components required and working with our Engineering team to setup the server-driven UI framework that would power the view.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7zKkyj4cg2UDE35sLLysoA.png" /><figcaption>A small sampling of all the components we had to create for the cupcake. Many of these were brand new components that didn’t exist in our design system. We worked closely with our Design Infrastructure team to create a new side navigation, a new persistent sheet, and several variations of data visualization that could go into the module component of the sheet. We were also using an upgraded theme that magnified type sizes and icons to make it more accessible while driving.</figcaption></figure><p>Creating these components was no small feat, particularly because we were approaching it with an intentional mindset of ensuring that we limit their scalability as much as possible. We didn’t want collars, tooltips, or banners in the components because it would lead us to the same problem we had on the old homescreen. Our goal was to <strong>enforce the governance and guidelines directly into the design of the components themselves.</strong></p><p>The exercise of creating all these components forced us to consider how they would be used across the entire Dasher app, not just the homescreen. We fixed, tweaked, and <strong>overhauled several foundational elements of the design system including color, type, spacing, and theming</strong> to ensure that all the components would work well across both iOS &amp; Android when all the information about the interface’s styling, layout, and rendering is being sent from a backend Mosaic response. This simply took a lot of work coordinating the build across multiple engineering teams to pull it off.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ioPpriOiCMGQcX35gc8r6w.png" /><figcaption>Because we weren’t touching the map in Milestone 1, we had to display the name of the zone somewhere, and we decided to put it on the sheet as a subheader. One more change we made in the cupcake was to bring safety tools back to the main homescreen as it was an important tool to have quick access to when Dashers neede to report safety incidents and keep the platform safe. We also pivoted to display wait times on the map instead of the ambiguous “Busy” labels</figcaption></figure><p>The single best decision we made when scoping the cupcake was to do the <strong>entire IA redesign as part of the first milestone</strong>. There were many paths we could’ve taken where we could’ve tackled this piecemeal, but none of them felt like they would accomplish the goals of what we were setting out to do. We absolutely <strong>needed the focus to be on earnings, dashing, and scheduling. And we couldn’t achieve that without drastically simplifying the IA to bring those things into focus by eliminating the clutter.</strong></p><p>The goal of the headline was to communicate what you needed to do in a few short words. This was incredibly challenging, as the type size was large (an intentional choice to ensure it was easy to glance at on-the-go) and needed to still translate to different languages without truncating. We spent a <em>lot</em> of time workshopping the tone &amp; voice of the headlines with our content design team to ensure that it hit <strong>the right balance of conveying useful information while also driving action to the best thing for a Dasher to do </strong>in each scenario (and there were literally dozens of scenarios).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bFsgDUvKlXFewOEMWLY5iA.png" /><figcaption>The key screens for Milestone 1 looked really close to our vision concept. We scoped the cupcake in a way where we landed nearly the entire IA redesign along with setting up the sheet framework to enable rapid experimentation with dozens of variations for the headline and module depending on the state of each zone.</figcaption></figure><p>I created all the various states we needed to account for. This required a lot of careful iteration to ensure that we were showing <strong>relevant, actionable, and targeted messaging to Dashers in every scenario</strong>. When it was a good time to dash, we would tell you that with a motivational headline and data. When we <em>really </em>needed you to dash and fulfill deliveries, we displayed a monetary incentive to get you to dash. When we knew it wasn’t a good time to make money, we showed you a forecast for the rest of the day and highlighted the next best time to come back. Our system didn’t work like this before, and we had to get extremely intentional about these states to make sure it was focused on one message at a time.</p><p>For me, this was <strong>a constant dance of figuring out what the needs of the product were and then ensuring that the components we’re building supported those needs</strong>. This meant working with multiple Product Managers at the same time to understand why a feature existed, whether or not that was the best way to solve that problem, and if we could try a different approach that leveraged the new homescreen framework instead. The majority of the time, PMs were open to trying a new design but had hesitations about their metrics tanking, which just required a lot of my time to explain why the new way of doing it was better and how it could actually help improve their metrics even more than the old way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZ0la7o9S8VJG-dAl9ADYg.png" /><figcaption>Offloading all the main navigation into a side menu helped immensely in keeping the main homescreen clean, allowing us to scale the sheet framework to a wide variety of use cases from displaying promos to onboarding and more. Our guideline was to enforce showing just one thing at a time, not dozens of messages.</figcaption></figure><p>Any and all worries about the rest of the screens in the app being too buried in the side menu were mitigated by figuring out what their concerns were and <strong>pitching a vision for how we could incorporate that thing into the homescreen itself in a targeted moment</strong>. For example, the Promos screen now takes an extra tap to get to from the side menu, but we can display the best and most motivational promo front and center on the new homescreen without anything else distracting from it. I did this over and over again for multiple features and this won people over internally easily.</p><p>Slowly but steadily, I managed to get multiple teams and PMs on board with migrating their features to the new homescreen. This helped immensely in ensuring that <strong>the homescreen’s design didn’t feel like a one-off thing but instead blended neatly into the rest of the experience. </strong>Once a Dasher completed the signup flow, they were greeted with a checklist that matched the IA of the new homescreen. Once their background check had cleared and they were all set to dash, the view smoothly transitioned into the new homescreen and let them start a dash immediately. This was <strong>a nice moment of delight</strong> that greatly boosted new Dasher activations (more on that later), which wasn’t even what we set out to do with this project.</p><h4>Time Mode</h4><p>A quick tangent into what was easily the most difficult part of designing the first milestone and nearly tanked the entire project multiple times: <em>Time Mode</em>. This was a feature live in certain markets that offered Dashers an alternative way of earning. Instead of evaluating each offer based on its pay and making a decision to take it or not (the default way of dashing in <em>Offer Mode</em>), <strong><em>Time Mode</em> allowed Dashers to earn an hourly rate instead</strong>, allowing a stress-free way of dashing by eliminating the offer-by-offer decision making that many say makes dashing stressful and tedious.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*la1DvoL8KX7lYzf7okRnRA.png" /><figcaption>Offer Mode (referred to in-app as “Earn per offer”) let you see the pay per delivery and make an accept or decline decision when offers came in. Time Mode (referred to in-app as “Earn by time”) let you earn a set rate per hour at the cost of not being able to decline more than one offer per hour. If you dashed for a certain length of time, you would earn more in Time Mode on average, but Dashers couldn’t know this when being asked to make the choice on the homescreen.</figcaption></figure><p>Sounds fine so far, right? The problem was how and where the decision to make this choice was presented to Dashers. In the old homescreen, there was a giant toggle to change between these two earnings modes, <strong>making it feel like the primary decision you had to make was to decide which mode to dash in</strong>. In reality, there’s a meta-decision you need to make even before that, which is whether you even want to dash right now or not. More importantly, choosing an earnings mode is an odd decision to force upon the Dasher before they even start their dash. Shouldn’t the product<strong> smartly default the Dasher into the mode that maximizes the earnings</strong> instead of making them deliberate about this choice every single time when they choose to dash?</p><p>These were the questions that I raised when figuring out how to migrate this feature to the new homescreen, and it <strong>opened up a massive can of worms involving how Dashers earn on the platform</strong>. I naively assumed that this would be like all the other dozens of features that I partnered with PMs on and migrated to the new homescreen, but this one was different. This feature had a long and storied history of why it existed, most of which I can’t go into too much detail about due to the how it ties in with DoorDash’s logistics and pay models. Long story short, we couldn’t just move the decision point away from the homescreen and <strong>needed the switcher that toggled between the two earnings modes available on the homescreen.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zMqHne2E4nCdO76MNAbW-A.png" /><figcaption>My very first concept involved displaying the switcher directly in the sheet, which could make room for some interesting interactions for how it appears into view and expands when needed, but the information architecture, hierarchy, and placement all felt off with this concept.</figcaption></figure><p>Embedding the switcher directly into the sheet was an option that was clear, simple, and straightforward. But the more you looked at it, the more problems it caused. <strong>We wanted to make sure the headlines had some parallel structure between the two earnings modes.</strong> For example, it felt confusing to have the <em>Offer Mode</em> headline referring to offer volume while the <em>Time Mode</em> headline referred to earnings. So we had to unify the two and communicate the same message to clearly differentiate the value prop between the two choices, so we were toying around the idea of displaying an earnings estimate for both (which wouldn’t work for many reasons). And <strong>because the entire UI is changing when you toggle the switch on, the placement of the switch didn’t feel global enough</strong>. The headline, wait times, earnings, and the map pins are all updating. It quickly became obvious that this placement didn’t work in the sheet and needed a different solution entirely that worked better with the information hierarchy.</p><p>Taking a step back, we had largely ignored this feature when designing the vision mocks assuming that we could move the choice to Preferences or put it elsewhere in the dash journey as it didn’t quite feel like the right fit on the homescreen. But given that we had to have it for the first milestone, I took on the challenge and decided to do my best with this constraint. I wanted to see if we could incorporate it elegantly without throwing off the core focus on dashing that we had set out to achieve. So I went down a deep rabbit hole of design explorations to figure out <strong>what the best way to switch between the two earnings modes on the homescreen was</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*viPirkOXYJPN75tEC3GxbQ.png" /><figcaption>Static explorations for how to present a mode switcher while distinguishing Time Mode as a different state of the homescreen entirely. It completely changed how you earned, so it needed some differentiation, but not so much that it completely overpowered the core decision of whether or not to dash right now.</figcaption></figure><p>If the <em>Offer Mode</em> headline said something like “Lots of offers in your area,” the <em>Time Mode</em> equivalent of the headline would have to match its structure while conveying the value prop. We were honing on the concept of <strong>adding on the idea of a guaranteed rate into the headlines to clearly distinguish the two earnings modes</strong>. The hope here was that when a Dasher toggles on <em>Time Mode</em>, there would be enough changing between the headline, the map pins, and the content in the module that it would truly feel like a state change of the homescreen from one to another.</p><p>Getting deeper into the explorations also made me realize that there wasn’t any visual identity for <em>Time Mode</em> as a feature. There was no brand language or distinctive elements that separated the two earnings modes, so I was also <strong>creating a new brand identity for <em>Time Mode</em> through these explorations.</strong> We also had to ensure that this would carry over to everywhere <em>Time Mode</em> showed up in the rest of the app, not just the homescreen. While we were figuring this out, our Engineering team was knocking on our doors incessantly for the Time Mode designs because they were actively building out the first milestone and they needed to spec and build this feature quickly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*__SEHXpf7PzVgQ7m6e-9uA.gif" /><figcaption>My top favorites of the dozens of explorations I did for how to add a mode switcher to the homescreen. My goal was to not make it feel like choosing an earnings mode was the primary decision to make on the homescreen (that honor goes to choosing whether or not to dash) while trying to seamlessly integrate it into the visual language for the homescreen. A toggle felt way too visually heavy and too prominent, so I needed to solve this with elegant interaction design.</figcaption></figure><p>As I narrowed down on my explorations, one constraint I really wanted to force is to <strong>keep the default state of the switch looking visually similar to the rest of the buttons</strong>. <strong>It needed to feel like it belonged in the same visual family as the rest of the buttons on the homescreen</strong> instead of feeling like an afterthought that was slapped on. The UX tradeoff here is that it wouldn’t be immediately obvious what the button was until you interacted with it, and we had a lot of debates within the design team about whether or not this was a worthwhile tradeoff.</p><p>I kept exploring ways to see if we could make the interaction design work by playing with the interaction of tapping the button and having the choice of the two modes come up. I must have made some fifty options for this, but <strong>the ones that seemed the most intuitive and simple were the ones that quickly switched to the other mode without forcing too many taps </strong>and let you preview the information in the other mode easily to make a decision about which mode to dash in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ML1o8Iys7aX9dqPxl7DwUQ.png" /><figcaption>A point of inspiration for me was how simple Apple’s mode switching is in the Control Center. Nearly all options have been simplifed to a binary on/off toggle, and I wanted to simulate something similar with Time Mode: what if we could collapse the entire interaction to just an on/off state toggle?</figcaption></figure><p>As I kept refining the final design, inspiration struck when I was idly toggling between light and dark modes on my phone to test bugs on the dev builds. <strong>How did Apple manage to make features that make such big app-wide changes down to a single on-off toggle?</strong> It applied to many different OS-level options and some of them were fairly complex, but the interaction of turning them on and off was simple. They were quick to access and easy to interact with. It led me to drastically simplify the interaction of toggling <em>Time Mode</em> on or off down to a similar concept.</p><p>I narrowed down the visual identity of Time Mode down to a subtle green gradient, just enough to visually differentiate it from the regular mode but not overpower it from the main reds being used in the view. Nailing this down was a fairly challenging task, because going any darker on the green made the screen look like Christmas lights with saturated reds and greens, so we wanted to keep it subtle.<strong> To solve the issue of not knowing what the button does, I came up with two solves: one automatically expanding switcher explaining what the button does and another more aggressive first-time user experience that looked &amp; felt special.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q0ndez4X72NGisE8zQypOg.gif" /><figcaption>The final design for the Time Mode switching experience that launched with the first milestone. It took a long and winding path to get to a simple and intuitive experience, but it was worth it. The animating hourglass with the custom animations added that extra bit of delight and made the toggle engaging to interact with. We also added several haptics to truly sell the “mode switch” effect, which felt really good to use in the app. Motion designs by Eric Henry.</figcaption></figure><p>To finalize the design, we landed on the hourglass icon to indicate Time Mode, as it was the best representation of earning by “time” without introducing a new metaphor. And to really take it the extra mile, we added an animation where the hourglass flipped upside down when you toggled it on (we also initially had a version where the sand flowed down, but it gave the false impression that the time would eventually run out and didn’t exactly read clearly at such a small scale, so I scrapped that). Combined with the discoverability expansion animation that automatically triggered as well as the first time education that triggered when the user firs interacted with the switch, we had it. <strong>The best mode switching experience on the homescreen that nailed the fine line between not making it feel like the main decision to make but still being accessible and visible enough to feel like a state change on the entire view</strong>.</p><p>At multiple times throughout these explorations, the entire homescreen design nearly changed multiple times. We couldn’t display earnings estimates on the homescreen for legal reasons and our content strategy for the headlines wasn’t working for the longest time until we sat down and defined the framework with multiple iterations. <strong>We really didn’t want to change the design of the entire homescreen just for this one single feature</strong>, so I did my best to fit it into the information architecture we had defined given all the constraints we were working with. The best part of this new design was that if we ever need to hide the switcher in certain markets or change it to a different mode in the future, it would scale really well with the placement and style of toggle we chose.</p><h4>The comms platform</h4><p>In parallel to all of this, work was underway on the new Comms Platform to host the banners, fullscreen takeover comms, tooltips, and announcements that displayed on the homescreen. This was a massive undertaking. <strong>Nothing like this existed before in the app and having this was an absolute requirement to remove all the banners, tooltips, and messages from the old homescreen.</strong> We defined and ironed out three key templates that all comms would need to fall into into in order to display it to Dashers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9mp5sQ1JJFK3BBBVPbcw0Q.png" /><figcaption>Our 3 key templates that we would support on the new homescreen. Everything had to fall into these buckets in order to show in the new homescreen.</figcaption></figure><p>We had two key types of comms we would support on the homescreen, both of which were framed around the act of dashing. <strong>A message could only be shown on the homescreen if it directly blocked you from dashing</strong> (like a contract violation or an account deactivation) or if it required you to take an action before starting a dash. Urgent, critical comms would still takeover the entire homescreen whereas others would still let you view the homescreen but would replace the content in the sheet. <strong>Everything else would go into the new Notifications Hub.</strong></p><p>We had to of course, design this new Notifications Hub as well since it didn’t really exist before. <strong>It needed to host a variety of different messages but still feel unified in its appearance as the go-to place for all comms from DoorDash</strong>. Our original plan was to merge Notifications and Messages into one view, but we had to keep them separated out for the first milestone due to the never-ending scope creep. We explored several designs for what this Notifications hub could look like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QsMKiFIp6GCPyjfCNbge6A.png" /><figcaption>Various options and explorations for the Notifications Hub that would host our Comms Platform. We started with big playful illustrations and eventually simplified it down to a minimalist version that put the focus on the content and not the illustrations or color of the icons. Designs by Lauren Prasad and Ruolan Xia.</figcaption></figure><p>We created icon pairings and guidelines for which types of comms fall into which category to avoid a situation where have fifty different icons and categories leading to confusion. This <strong>needed to be an air-tight platform to ensure that teams don’t create one-off comms that look &amp; feel different from the others. </strong>We had strict rules on character limits, time formatting, and the visual styling for reads and unreads. Our partner teams were super excited that something like this finally existed.</p><p>Despite all this, getting teams to adopt the new Comms Platform was no easy task. Because the homescreen was still being built and the user-facing launch was months away, teams internally continued shipping banners and tooltips in the old homescreen despite us telling them that we’re not doing that anymore. This caused a swirl of confusion about how to even message something on the homescreen, so we had to<strong> create a robust framework that explicitly called out what the guidelines are and what not to do.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z_BLuDMlsIRuBv0SzVQvWQ.png" /><figcaption>Do’s and don’ts on the new homescreen when it comes to comms. We intentionally didn’t support any UI template on the new homescreen platform that could display banners, toasts, or tooltips. The focus should be singular and should always be on dashing. Everything else is secondary. Designs by Ruolan Xia.</figcaption></figure><p>Our plan was to slowly get the design team onboard first and design comms for the new homescreen. Then the engineering teams would need to migrate those old comms into one of 3 new frameworks we had defined. This was a mammoth effort that took several months. <strong>We had hundreds of messages being shown on the old homescreen, and we had to rally the entire org to migrate all of them to the new homescreen. </strong>The forcing function to get them to do it was that if they didn’t do it, the message won’t have a way to be displayed on the new homescreen because it was an entirely new codebase which wasn’t pulling from the old homescreen.</p><p>Slowly but steadily, all of them got migrated over. This was an exhausting task that required dozens upon dozens of weekly meetings to ensure teams were migrating them correctly and needed us to unblock any issues they ran into with the migration. These teams were dropping all the ongoing feature work they were doing just to migrate their comms to the new service. It was a lot of work, but it had to be done. After months of this, we got to the day when all the comms were fully migrated over to the new homescreen platform.</p><h4>Prioritizing delight</h4><p>We had set an ambitious goal to ensure that every milestone of this project ships with the highest level of quality and craftsmanship, and we intended to deliver on that promise. These would be the little micro-interactions that make the app <em>feel </em>fun and delightful to use. On almost every project I’ve worked on in the past, these things were usually the first on the cutting block to get scoped out of the MVP. But <strong>we were building a cupcake, and no cupcake is complete without its cherry-on-top.</strong></p><p>We worked with our talented Motion Designer Eric Henry to figure out the best entry animation for every single UI element. We set a goal for what the purpose of each button, module, or icon was and what we wanted the motion to communicate: things like joy, urgency, speed, or satisfaction. These are inherently intangible things that can’t be measured by a metric, so we had to just explore several options and choose ones that we felt hit on those tones we wanted to achieve with the animations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vlEaewmYrA1epgSfvlHHoA.gif" /><figcaption>Entry animations for UI elements that were built directly into the components themselves. Motion designs by Eric Henry.</figcaption></figure><p>The Notifications bell was a critical component because<strong> it needed to clearly indicate that unread messages were in that screen</strong>. All the comms had been moved to the Notifications Hub, and we landed on an elegant ringing animation that wasn’t too distracting to draw attention to unread messages. The Earnings Pill tally animation was another crucial one to nail down because we wanted it to <strong>visually reinforce that the Dasher app was an earnings platform first and foremost</strong>. It’s the #1 reason you come to the app and this animation served as a constant reminder of that, motivating you to go online and keep getting that number to tick up higher.</p><p>Every single module in the sheet had its own animations as well. These were robust, componentized elements that lived in a design system and we wanted them to be <strong>reusable for any use case that the components could scale to</strong>. The graph forecast could scale to display an earnings forecast and the progress bar could scale to display a variety of indicators that displayed progress towards a goal. We wanted all of these to animate and behave in a consistent manner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LPFLDhFANmwgnYJ1UF0Izg.gif" /><figcaption>The Time Mode motion kit building on its new visual identity. Motion design by Eric Henry.</figcaption></figure><p><em>Time Mode</em> was, again, its own beast. We <em>really </em>wanted this to feel good. <strong>We wanted the action of tapping the switch to feel so satisfying that you would want to keep tapping it all the time</strong>, even if your intent wasn’t to ever dash in this earnings mode. So we spent a lot of time exploring options for how to trigger the state change from <em>Offer Mode</em> to <em>Time Mode</em>. We created detailed specs for how the hourglass physically flips from an off state to an on state where the sand then goes on top. Our explorations for the sand dripping down were cool but got scrapped because they didn’t read clearly at a small scale and falsely conveyed a non-existent time limit.</p><p>Building on the visual language we had established for Time Mode, we <strong>made it feel extra special by having a continually looping gradient</strong> that we leveraged everywhere the hourly rate was shown. This set Time Mode apart from everything else on the homescreen, because it was the only thing that had an infinitely looping animation. Even the first-time education experience that took over the view with a circular pulse and the expanding switcher that improved discoverability utilized this to its full extent. Overall, we had <strong>completely transformed this feature that had previously felt like an afterthought on the old homescreen slapped together as a toggle to something that we felt was way more thoughtful and well-crafted with intention</strong> in regards to how it related to other elements on the homescreen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HbTE6BaWF2FBPPCng8pkOA.gif" /><figcaption>How it all comes together: the final motion specs for how the homescreen first appears into view, how the side menu opens and closes, and what the interaction of tapping other zones on the map feels like. Motion designs by Eric Henry.</figcaption></figure><p>We sweat the details on literally everything. The first time loading experience needed to have several latency states where everything gradually loaded into view as various API calls were being made, so we accounted for this with many lazy loading shimmer elements. We also didn’t want to overwhelm users with multiple animations triggering simultaneously, so we sequenced the animations with delays to get them to trigger at specific times or after one another.</p><p>We even added <strong>gesture interactions to the side menu to make it easier to open</strong> and not need to physically tap a button on the top-left of the view to access the rest of the app. And finally, the action of tapping different zones was the main thing you did on this view (aside from actually tapping Dash), so I spent a lot of time with the engineers <strong>working through the details of how a zone you tapped centers itself into view, how the map animates from one zone to the next, and how the sheet content updates</strong> in sync with the map animations so that they look optically choreographed to happen at the same time. It was a lot of manual testing and fine-tuning.</p><h4>Code complete</h4><p>It took our engineering team <strong>six months to scope, plan, architect, and build in piecemeal all the different components of the first milestone</strong>. My time during these six months was spent designing the remaining features, leading the design team to finalize the remaining design decisions, communicating with stakeholders about progress &amp; blockers, and co-ordinating the build of several UI components and comms templates. This took a lot of time &amp; energy, and it was exhausting. One thing that worked really well is that our <strong>team was constantly launching the latest updates to internal builds that I could test and give feedback o</strong>n throughout this entire build phase. Issues with transitions, navigation, and app crashes were easily caught this way and put on our roadmap for the team to fix.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aT9N58gSESVnDpY49yd3cA.png" /><figcaption>A very rough timeline breakdown of how long it took (in months) across the different disciplines of the core working team to pull off a redesign as big as this. Not pictured are the Managers, Leads, Technical Program Managers, and multiple other teams across the org who supported this project</figcaption></figure><p>I don’t want to undersell how much work this actually was. I was doing visual QA on the app across both iOS &amp; Android pretty much every day for most of the build phase, was flagging and following up on bugs with nine different engineering teams at the org, and was doing my best to answer the onslaught of questions from the engineering team about how some weird edge case they found should behave. <strong>I stepped in several times to ensure that everything got built exactly as designed, often playing the role of Product Manager or Tech Lead or the Technical Program Manager </strong>in meetings. Every week was a non-stop sprint of making sure that all the different ongoing workstreams were going as planned, and every week there were fifty fires to put out that continually put our launch timeline at risk. But after a lot of co-ordination and rallying, we got it done.</p><h3>V: The new Dasher app</h3><h4>Rollout</h4><p>What started as a redesign of the homescreen quickly became a redesign of most of the app’s offline state (i.e., when you’re not dashing). <strong>We touched and tweaked nearly every single screen in the app outside the core delivery flow, and it was a big change.</strong> We needed to make sure that the update was actually moving metrics in the right direction and ramp up slowly to catch any critical issues, because the alternative would be rolling users back to the old homescreen if something went wrong (which none of us wanted).</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F4c0w1kyeOuE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D4c0w1kyeOuE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F4c0w1kyeOuE%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ffa2b49a734f63d8edd4d370751c6573/href">https://medium.com/media/ffa2b49a734f63d8edd4d370751c6573/href</a></iframe><p>After ramping up to a critical mass, we saw positive movement in the data we cared the most about (exact numbers not disclosed):</p><ul><li><strong>More Dashers were starting dashes</strong> from the homescreen</li><li>Dashers were making the decision to dash <strong>faster than before</strong></li><li>New Dashers were <strong>starting dashes more frequently</strong></li></ul><p>This was all very exciting, because it signaled that we achieved what we set out to do. We wanted to help Dashers decide whether or not it was a good time to dash without a dozen buttons, messages, and choices getting in the way of that decision. And it worked. Removing all the buttons to a side menu, migrating all the comms to the Notifications hub, and cleaning up the IA to keep the focus on dashing and not on the other actions available in the view <strong>helped Dashers stay focused on the decision to dash and they were able to make that choice faster than before, resulting in them dashing more often.</strong> I breathed a huge sigh of relief when we confirmed this in our rollout metrics.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fye8sgQhgDdg%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dye8sgQhgDdg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fye8sgQhgDdg%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2d4a900373b60688c2ca1331694d413/href">https://medium.com/media/e2d4a900373b60688c2ca1331694d413/href</a></iframe><p>We had been slowly doing small alpha tests to select groups of Dashers to test the marketing narrative and see how it would land with Dashers. All signals were positive, with many calling out that it helped them stay more focused when driving and that they found the changes useful in making a decision to dash or not. These tests were also helpful in identifying what Dashers found confusing about the changes, which we solved by improving our educational messaging and comms around the features. <strong>We made a splash by launching a </strong><a href="https://about.doordash.com/en-us/news/delivering-a-better-experience-for-dashers"><strong>marketing moment around the redesign</strong></a><strong>, which generated a fair amount of buzz.</strong></p><p>Not all feedback was positive, though. Once our rollout started hitting all Dashers, the initial wave of negative sentiment kicked in. This is something that I had prepared the team to expect, because <strong>every redesign is always met with a strong initial reaction of “<em>What the hell is this?</em>” when users first see it. They’re not reacting to the design, they just hate the fact that things are changing. </strong>It’s really important to hold your ground and not make any drastic changes for a few weeks to let the change friction settle in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XWbcu3pQz_qe8Wig2KOKkA.png" /><figcaption>A small sampling of comments online about the change. Most of the negative feedback is primarily change friction and needing to give the update some time to settle. Getting extreme reactions on both ends about your redesign means that it worked: it changed enough things to make people notice and feel it. The worst outcome of a redesign is a “meh” neutral reaction, where you might as well have not changed anything.</figcaption></figure><p>I didn’t take any of the negative feedback personally, being fully aware that online spaces amplify the sensational and negative posts while drowning out the ones with positive or neutral reactions (if they even post about it online in the first place). <strong>Every small piece of praise for the redesign was equivalent in weight to thirty negative remarks about it due to the nature of how people share opinions online.</strong> You can’t satisfy everyone, and there will always be some people for whom your design won’t resonate, and that’s fine. At the end of the day, I would <strong>much rather have the extreme ends of positive and negative reactions to a redesign than have it be a neutral one where users don’t feel any particular way about it</strong> (at which point you would have to question why you even designed and shipped it).</p><p>Once the dust settled, people got used to it. Everyone forgot how bad the old homescreen was and got used to the redesigned one as the “new normal.” We had a social monitoring channel setup that scraped Reddit and posted feedback in a Slack channel, which we were all watching like hawks to see if anyone found any breaking bug or found something exceptionally confusing. Aside from a few small bugs, we were in the clear. We continued to rollout to all markets around the world and deprecated the old homescreen for good, ushering in<strong> a new foundation for the Dasher app going forward. </strong>It was even <a href="https://www.businessinsider.com/doordash-makes-corporate-staff-moonlight-as-delivery-workers-wedash-2025-11">covered in the press</a> about how employees shaped the redesign to deliver a better experience for Dashers.</p><h4>Lessons learned</h4><p>This was a journey spanning nearly two years from the moment I began collecting examples of how bad the old homescreen to the day we rolled out the new homescreen cupcake to all Dashers. At a company as large and complex as DoorDash, it wasn’t easy. Here’s the main things I took away from this experience:</p><ol><li><strong>Bring the team into the process early: </strong>Every discipline, from Product Management to Analytics to Engineering, was part of the process from Day 1 when we did the design sprint. This made it feel like like a team sport and that everyone was building something together.</li><li><strong>Continually socialize the “why”: </strong>For nearly every week during the first 6–8 months, someone would ask why we’re even working on this. It took lots of 1-on-1’s, decks, and shareouts to get everyone to understand what’s broken about the old homescreen and why we needed to fix it.</li><li><strong>Lead with vision to get buy-in: </strong>You will 100% run into mixed feedback and contradicting opinions about your design. It’s impossible to avoid this. The best you can do is explain your process, talk through your reasoning, and show them the data that helped inform the vision. After enough time, people will come around and respect you more for it.</li><li><strong>Show progress early and often: </strong>The last thing you want to happen with a project as big as this is to go deep into a stealth build rabbit hole and not communicate status. We did monthly demos with leads and regularly QA’d the app as every feature rolled out, which helped build confidence that things were going well and that we were on track to hit our launch timeline.</li><li><strong>Play all four quarters of the ballgame: </strong>You will need to adapt from being a Designer in the first quarter that creates a vision to a Design Engineer in the second quarter that helps the team figure out how to build the vision. You’ll need to go from Roadshow Marketer in the third quarter that gets everyone on board to being a Quality Assurance hawk in the fourth quarter that catches every problem and puts out every fire. And you’ll need to be prepared to play multiple overtimes for any issues that come up during rollout. This is not a vision you can throw over a wall to hand it off and expect it to get built, so strap in until the game is over and make sure you’re prepared to run out the clock.</li></ol><p>The hardest part of this project was undoubtably the Comms Platform, which required <strong>convincing nearly every team in the org to move a banner that was performing well (in terms of metrics) to <em>not</em> display on the main homescreen of the app.</strong> Aside from that, this was the first screen in the Dasher app to use the new theme for larger fonts and buttons, which made it feel <em>very </em>different than the rest of the app and it caused some strong reactions from the rest of the team. Again, this just took lots of re-iterating and backing up why we made the choices we did.</p><h4>Sooo…what’s next?</h4><p>As we know, a cupcake is just the first milestone. At DoorDash, <strong>we build cupcakes with the goal of building a birthday cake next and a wedding cake after.</strong> The next phase of the vision is to build out the online state that we had descoped from the cupcake and make all the map improvements that we had left out as well. While the cupcake was rolling out, I began scoping and shaping the online state designs.</p><p>The online state, called the Looking for offers screen, is the screen you see <em>after </em>you tap the Dash button. In many ways, <strong>this view is even more important than the homescreen as it’s the view users keep returning to after completing every single delivery. </strong>It’s where they wait for their next offer. The #1 thing this view is responsible for is to tell you what you need to do: Should you spend gas &amp; time driving around from restaurant to restaurant hoping to get an offer? Or should you just wait where you are? Turns out the screen was failing at the main thing it was supposed to do.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*svvjqm__HgCAWlNXzPeErA.gif" /><figcaption>The main job of the Looking for offers screen was to get you to go to hotspots (busy areas within a zone), and it wasn’t doing a good job. There was no differentiation in the UI between whether or not you were at a hotspot, resulting in a confusing experience for users about what to do. The new design clearly differentiates the experience by telling you to either stay put (if you’re at a hotspot) or go to a hotspot (if you’re not at one). Motion designs by Eric Henry.</figcaption></figure><p>Because we were re-using most of the components setup for the cupcake, the design specs and build for this milestone went much faster. Our goal was primarily to refresh the UI of the online state and clearly differentiate the experience when you were at or not at a hotspot. On top of that, <strong>I wanted this view to feel like a moment of calm in a hectic journey of back-to-back deliveries.</strong> Nearly every view in the Dasher app is asking something of you, often under time pressure. This is the only view where once you’ve made it to a hotspot, <strong>you get to just take a minute and breathe</strong> without the app constantly spamming you with buttons and actions.</p><p>That being said, there are moments where we need to get input from you even when you’re at a hotspot. The zone you’re in could have gotten lots of Dashers to the point where your wait time becomes extremely long or we need you to provide a signal to the system about what you’re willing to do. So I had to <strong>define another comms framework on this view</strong> to ensure that we do this in a careful and calculated manner without opening the floodgates for any team to add anything on the sheet, which would essentially lead us to the same problem we had before on both the old homescreen and old Looking for offers screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HfztcbvdCxdSzO2K6hNDtw.gif" /><figcaption>A comms framework on the new Looking for offers screen that only displays one thing at a time, avoiding the cascading banners and mixed messaging that existed on the old view. The hard rule I had to enforce here was that these would only display when you had made it to a hotspot and only under very specific conditions to ensure that your moment of calm doesn’t get ruined by back-to-back messages asking yet another thing of you.</figcaption></figure><p>The side menu carried over into the online state, and we added a shortcut to Preferences directly above the sheet. Quick access to support was of the essence when you were on a dash, and that replaced Notifications &amp; Messages on the top-right of the screen. SafeDash remained where it is on the homescreen to always provide access to safety tools and peace of mind for Dashers. <strong>The Earnings Pill elegantly scaled from showing earnings for the week to displaying earnings for that specific dash</strong>, and we had plans to play with it even more going forward to scale it to all kinds of fun things.</p><p>The best part about re-using the same information architecture as the homescreen is that it made the transition from starting a dash to finding an offer feel incredibly smooth and seamless. Best of all, this scaled to our vision of <strong>displaying hotspots directly on the homescreen and eliminated the need for displaying zone boundaries completely</strong>. The act of starting a dash was previously a clunky and cumbersome process, but it became elegant and streamlined with this update.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e97Ehjna4MCGRhrUVZVg9w.gif" /><figcaption>Tapping “Dash” and landing on the Looking for offers screen with this update. If you’re already at a hotspot when you start the dash, you’re just told to wait where you are. But if you aren’t at a hotspot, you’re told to navigate to the one nearest to you (or the best one based on your Dasher profile).</figcaption></figure><p>I could write another hour-long blog post of all the design thinking and decision drama about the online state, but it’s too soon. The experience is still being built out and we’re investing in a massive change to our underlying systems to power this kind of hotspot-level routing and prediction models that’s shown in the vision. All of this ladders up to our original vision to<strong> get Dashers to their first earnings opportunity faster. This is the birthday cake vision for the redesign.</strong></p><p>Once that’s done, the plan is to move on to the transition from the Looking for offers state screen to the Accept Modal, arguably the most important screen in the entirety of the Dasher app as it’s the view where every Dasher makes an accept or decline decision about fulfilling offers. We’re actively investing in redesigning the experience right now. Once we nail this and make the map updates we’ve been dreaming up, <strong>we’ll have landed the wedding cake vision for this massive, crazy, and ambitious redesign.</strong></p><h4>Conclusion</h4><p><strong>Roughly ~60% of the content in this blog post is what happened in the first 3 months</strong>, and the rest is what happened after. I skipped over the long slog of alignment meetings and engineering specs and writing feature documentation because it’s just not that much interesting or fun to read about in that phase. The truth is, <strong>much of this work in the build phase is a boring grind</strong>, and you need to constantly remind the team of the light at the end of the tunnel. It’s important to celebrate every milestone and make sure everyone doesn’t get burned out or tired throughout this marathon.</p><p>I didn’t even talk about my core team and cross-functional partners rotated throughout the project and I had to spend hours and days ramping them up on what we’re doing and why we were doing it. I skipped over all the tedious documents I wrote about bugs and issues I found when testing. I <strong>glossed over how many meetings and reviews it took </strong>to build the components we needed for the cupcake. I left out all the times I had to stay on long calls with engineers late into the evening to figure out how to get a specific animation to behave correctly as expected, often going into deep dives of how to resolve some weird bug in the code. The reality is that you have to do all of this to pull of a redesign as big in scope as this at the level of quality &amp; craft that we were shooting for (those details just aren’t engaging or entertaining to read about).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aHMaMCqJ43ZPKHzygtcwbw.png" /><figcaption>The new Dasher app, with the redesigned homescreen prominently featured in the App Store screenshots.</figcaption></figure><p>Finally, I’d like to give an enormous shout out to the entire team spanning several disciplines and focus areas that made this project happen: Samiksha Kothari, Ruolan Xia, Ye Shin, James Woodbury, Archit Jha, Jon Brennan, Ashmita Vishwanathan, Ellani Johnson, Thiago Duarte, Matthew Burg, Lauren Prasad, Tony Ferreira, Eric Henry, Zachary Friedman, Aidin Massoudi, Jay Castro, Sarah McCurdy, Priya Kothari, Crane Huang, Jeyda Kaynatma, Ethan Wang, Daniel Madwed, Claire Blumenthal, Colin Schoppert, Anjali Narang, Vincent Artigue, Kyle Straub, Kyle Rhee, Emma Krikorian, Austin Haugen, Lillian Liu, Kris Szewczyk, Lindsey Menges, Ben Munge, Swaroop Reddy Mukku, Abhijeet Bhorkar, Romil Bansal, Hamlin Liu, Anaga Rajan, Vince Chau, Prabhat Kumar, Max Linsenbard, Emma Rivera, Amro Gazlan, Mahyar Varasteh, Devesh Sanghvi, Blossom Woo, Linda Martinez, Jose Carmona, Srijita Srivastava, Sam Gerardi, Khizer Syed, Vitali Horbik, Ashwin Chalikum, Alex Reilly, Yixin Liu, Ben Fleishhacker, Shreya Maheshwari, Kelvin Fan, Po-Han Chen, Wentian Ji, Srini Vedanarayan, Niting Qi, Andrii Kurshyn, Shan Zhong, Jason Yao, Tom Zhang, Nathan Lin, Fernando Goulart, Adilson Atalla, Bosai Chen, Sean Lee, Shannonn Russell, Dhaval Adhav, Walid Malih, Joy Xiao, Philip Sawyer, Jacob Dannhausen-Brun, Deepak Ramadass, Katie Lee, Prakash Rajan, Howard Deshong, Alex Diaz, Cillian Clinton, Laura Feilmeier, Jenna Price, Jenn Rosenberg, Austin Lomax, Jonathan Lieberman, and countless others who contributed in ways big and small who I’m most definitely missing here.</p><p>If you’ve made it all the way down here, a sincere thank you for reading through all of this. I hope this has served as an interesting behind-the-scenes look into what it actually takes to ship a big and ambitious redesign in an industry where most vision work doesn’t ever see the light of day. At the very least, I hope you walk away with an appreciation for what actually takes to pull it off. Feel free to reach out to me for any questions on <a href="https://bsky.app/profile/akhil17.bsky.social">Bluesky</a> or email me directly at dakinedi@gmail.com Cheers! ✌️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f40d1b09ba8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Pt. 2/2] Vibe coding my way to the App Store]]></title>
            <link>https://medium.com/@a_kill_/pt-2-2-vibe-coding-my-way-to-the-app-store-1ff57588ab41?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ff57588ab41</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[poker]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Tue, 27 May 2025 01:28:50 GMT</pubDate>
            <atom:updated>2025-05-31T06:27:59.869Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9s8rqbu21khBE1Uj2lsV3g.png" /></figure><p>Part 2/2 of deep-dive case study on how I prototyped, built, and shipped <a href="https://apps.apple.com/us/app/poker-slam/id6745245227?platform=iphone">Poker Slam</a> to the iOS App Store using Cursor.</p><p>Check out <a href="https://medium.com/@a_kill_/pt-1-2-vibe-coding-my-way-to-the-app-store-539d90accc45"><strong><em>Part 1</em></strong> of this series</a> to catch up on:</p><ul><li>Chapter I: Intro to vibe coding</li><li>Chapter II: The path to prototyping</li><li>Chapter III: Building the game</li></ul><p>Continue with <strong><em>Part 2</em></strong> in this post below:</p><ul><li>Chapter IV: Refining the UI</li><li>Chapter V: Releasing to the App Store</li><li>Chapter VI: Lessons learned</li></ul><p>If you don’t have time to read the full blog post, check out the abridged video version:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F1089278854%3Fapp_id%3D122963&amp;dntp=1&amp;display_name=Vimeo&amp;url=https%3A%2F%2Fvimeo.com%2F1089278854&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F2021681233-1450e09ee894484f61cb3502d801a6f95c407bb33a2f1f1cb395cafc2684ca1f-d_1280%3Fregion%3Dus&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1080" frameborder="0" scrolling="no"><a href="https://medium.com/media/47e674fc4503bbcef5e090137a700b36/href">https://medium.com/media/47e674fc4503bbcef5e090137a700b36/href</a></iframe><h3>Chapter IV: Refining the UI</h3><p>This is the phase I was most excited for. I had tons of Codepen samples, YouTube tutorials, and WWDC links bookmarked that I pulled up and started looking through various effects to see what would match the look &amp; feel of my game.<strong> I didn’t really have a desired aesthetic in mind, I just wanted to try a bunch of effects and see what looked good</strong>. I’ll add that this was a strange and different way of approaching a project than I usually do, where I tend to have a pretty good sense of what the final outcome should look like through either Figma mocks or a visual reference. <strong>This was all being created and adapted on-the-fly based entirely on vibes, which was a fun and different way of “designing” for me.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lGzbNaAhu-FlvYaSsf1L_g.png" /><figcaption>This <a href="https://developer.apple.com/videos/play/wwdc2024/10151/">WWDC talk by Apple</a> is one I referenced a lot for visual effects &amp; animation, to the point where I would copy the code samples from the demo and give it to Cursor to try and implement a similar behavior</figcaption></figure><h4>Gestures</h4><p>The first thing I wanted to try was to <strong>actually implement gestures </strong>so that you could swipe over a set of cards to select them and release to submit them instead of needing to tap individual cards. I had delayed this in the initial implementation due to the complexity of the interaction design, but wanted to revisit it now. I tried several times prompting different models in Cursor to implement this, but none of them seemed to understand the desired behavior I wanted. Here’s a small glimpse of the issues I ran into:</p><ol><li><strong>Swipe gestures were not selecting cards immediately</strong> when the input is entering their boundary, making it feel like a bug where the game is unresponsive or has some input lag</li><li><strong>Crossing the gap from one card to another</strong> while swiping over them momentarily caused the existing card to get “unselected” which felt like a jarring visual glitch</li><li><strong>Attempting to select cards diagonally by swiping caused a whole bag of issues </strong>where it was way too easy to accidentally select the cards directly adjacent instead of diagonally adjacent. Even with multiple tweaks to the detection threshold, this never felt right</li><li><strong>Releasing the swipe gesture to “submit” the selection felt off because the player doesn’t have a chance to preview their final set of cards before submitting</strong>. The expectation is often to release, confirm, and then submit. So I removed the instant submit, which left the cards in a selected state with the “Play hand” button still shown. Now, how would a player add another card to the set with a swipe gesture? Swipe from the set of cards to the new one? This also felt unintuitive and awkward. I kept the tap gesture to allow tapping or swiping, but that caused more interaction issues with two different ways to select cards</li><li><strong>When swiping to select cards, you had to go in order and commit to the sequence before starting the gesture</strong>. You couldn’t, for example, start swiping over three cards, then decide you want to undo the most recent two cards and go in a different direction from the starting card. This was technically solvable and I sort of had a version of it working, but the the code to allow this kind of dynamic selection was causing massive performance lags in the game, which didn’t feel good.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GCZ945GPsi-MR_BHTv_6Zg.png" /><figcaption>A static storyboard of how I imagined swipe gestures to work. You would swipe over the cards you want to create a hand out of, and it auto-plays the hand when you release it. This felt intuitive and fast but it didn’t let you preview/change the hand easily, resulting in a lot of “Oh I didn’t mean to play that, I wanted to add a different card to the set!” kind of moments because it felt like too many things were happening automatically without a confirmation step</figcaption></figure><p>After trying several workarounds to all these issues, I did eventually get gestures working in a hacky state with several build warnings in XCode. It wasn’t perfect and was still very buggy. <strong>I ended up still needing to have the tap interactions to select cards because there were a few states where you couldn’t actually create the selection you wanted through the swipe gesture alone</strong>. There were also certain ways of swiping too fast or across some invalid selection of cards that were causing animation lags and delays. <strong>I was leaning towards just not having gestures at all </strong>and just keep the tap gesture to select and unselect cards to keep it simple.</p><p>The final nail in the coffin was when I had asked my wife to playtest the build and she mentioned that she <strong>simply preferred tapping the cards one-by-one instead of swiping.</strong> When swiping, she was covering up the cards with her thumb and couldn’t pre-plan the entire set beforehand. When tapping, she could strategically select cards one-by-one, evaluate the nearby cards around the set easily, and choose the best option while keeping all cards in view. That was all I needed. <strong>Tap gestures, the original implementation, allowed for more tactical and strategic gameplay over the convoluted and messy swipe gestures</strong> that were giving both me and Cursor a massive headache, so I decided to simply<strong> not implement swipe gestures at all and just keep it to tap gestures to select cards.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8rPx7ex1LDZU1daasW60oQ.png" /><figcaption>In my second shot at gestures, I removed the auto-submit functionality and brought back the “Play hand” action. But Step 3 has dozens of different edge cases you could get into when you try to undo or revert the selection. Erasing and swiping over a new set of cards required unselecting the entire previous set. What felt best was swiping to start with, letting go, and then tapping to select the last card or two after analyzing the board. This meant I needed to support both swipe AND tap actions, which was getting very complicated with touch inputs very fast, and it was causing a fair bit of performance/animation lag that impacted gameplay</figcaption></figure><p><strong>I was a bit annoyed at how many hours I spent fiddling with Cursor to get swipe gestures to work right and got like 70% of the way there before deciding to kill it</strong>, but this is what vibe coding is like. Your idea may not work until your prototype it, try it out, and evaluate tradeoffs for whether or not to take it all the way, and ultimately make a call to kill it or keep working on it (which isn’t unlike actual product design for specific features). This is just one of many examples where I really had to learn the hard way what AI can and can’t do well and how much of a timesink it can be to prototype very specific desired behaviors when it comes to interaction design with AI models.</p><h4>Visuals &amp; type</h4><p>Dejected by the gesture failure, I moved on to simpler things that I knew were possible, like the actual UI. For the first time in this project, I actually felt like I was in familiar territory. I started by cleaning up some of the visual language for the cards and <strong>make the suits feel visually distinct from each other but not so distinct that all the players would play would be flushes</strong>. I also added a <a href="https://developer.apple.com/documentation/swiftui/material">material background to the cards</a> so that it would inherit some translucency from the background of the entire view. I made some styling changes to the connecting line visuals as well as the selected, unselected, and ineligible-for-selection card states so that they all <strong>clearly communicated the state of the game.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q1HGKhk_WxPTjM0GvVRICQ.png" /><figcaption>I redid the colors for all the cards and updated the selection states to be visually clearer. I was also experimenting with different colors for the background gradient at this stage</figcaption></figure><p>I also added a custom font called <a href="https://fonts.google.com/specimen/Kanit">Kanit</a> that I felt worked well for legibility at small scale and defined a type hierarchy for it to apply specific type styles to different parts of the UI. <strong>The typeface had large counters, clearly differentiated lowercase and uppercase letters, and was highly readable in the bold variants in sizes as small as 12pts</strong>, which is how I was planning to use it. XCode has a very messy system of implementing custom fonts that I painstakingly followed after asking Cursor how to go about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tPpBU2chkUHquEA-c0ux1Q.png" /><figcaption>XCode doesn’t make anything easy. Adding custom fonts involves adding them all into the Fonts folder and then manually adding every single variant of it in the Info.plist file. Sometimes I find it hard to believe that XCode was made by the same company that made the iPhone</figcaption></figure><h4>Mesh gradient background</h4><p>One thing I knew I really wanted in this project was a <strong>giant, infinitely looping gradient in the background.</strong> I remember seeing the <a href="http://developer.apple.com/videos/play/wwdc2024/10151/?time=381">reveal for this in WWDC</a> and was <strong>so mesmerized by how these gradients seamlessly blended colors and moved across the screen.</strong> I had to try this out. Luckily for me, there was lots of <a href="https://developer.apple.com/documentation/SwiftUI/MeshGradient">robust documentation for this from Apple</a> as well as tons of <a href="https://designcode.io/swiftui-handbook-mesh-gradient">excellent tutorials</a> on how to implement the infinite looping effect. I followed some sample prompts and literally gave Cursor links to the tutorial sites and asked it to implement one for me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OfPza5sJB3Vc1sXIUgvNSw.png" /><figcaption>A static mesh gradient with predefined colors that I gave Cursor. I linked several tutorials and asked it to follow the spec to create this, which it did easily and all I had to do was play with the color values to get it to look the way I wanted it to. Creating the base static version was easy enough, the hard part was animating it</figcaption></figure><p>And voila, we had a working mesh gradient! XCode did warn me several times that this was only available in iOS18+, which I was fine with, and it did implement a fallback for older iOS versions that just used a regular gradient. The interesting thing about the mesh gradient implementation is that Cursor didn’t automatically use the MeshGradient() function available in Swift when I specifically asked it to use it, it just created a random linear gradient. I had to be extra explicit about the fact that I wanted to use the MeshGradient() function so that I could leverage Swift’s native animation capabilities here.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OB28jVBVcHqC40XWmIt_Qw.png" /><figcaption>At its core, the setup for a MeshGradient() is very simple: you have one array of positions and one array of colors. You can animate between them in any combination and with any function.</figcaption></figure><p>One tough part of the mesh gradient is previewing the effect before coding it. There’s no good way to know at what point the color blending looks bad or what colors even look good. I found a <a href="https://www.youtube.com/watch?v=zWW--SAoyVc">developer who had built a MacOS application</a> to solve exactly this pain point. You could play around with different grid sizes, colors, and values in the tool before telling Cursor to build it and avoiding wasting your tokens. <strong>I spent a lot of time fine-tuning values in the Mesh gradient preview tool</strong> and came up with a nice purple scheme for the gradient that I thought would look good as a permanent infinitely looping background for my game while the cards on the grid inherit some translucency from it with the material background.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*YWS47oHZpat1LVHouOuI_Q.gif" /><figcaption>Shout out to <a href="https://www.youtube.com/@StewartLynch">Stewart Lynch</a> for this super helpful MacOS app that lets you preview and play with mesh gradients, where I spent a lot of time experimenting with colors and positions to animate between. The best part is that you can directly copy the code and give it to Cursor to implement.</figcaption></figure><p>I had initially defined a specific set of points that the gradient colors should animate to, which made the looping animation feel sort of rigid and linear. I wanted a more dynamic feel where there’s more variation in how the colors are moving around the screen. I found another t<a href="https://www.rudrank.com/exploring-swiftui-animating-mesh-gradient-with-colors-in-ios-18/">utorial that varied the points by using a cosine curve function</a> to animate the movement, which created a really <strong>nice, elegant color blend movement without it feeling too rigid.</strong> I loved it, so I had Cursor build it in my implementation of the mesh gradient background. It worked and looked really solid, so I had Cursor set it as the permanent looping background for my app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*4miphDoK1JMg1xicPt_XNg.gif" /><figcaption>The final mesh gradient background using a cosine curve to infinitely loop between positions which gave it more of a natural motion that felt varied on every loop. This was the main background for the entire app on every single view, I liked how it was subtle without being too distracting even when cards were overlaid on top</figcaption></figure><p>I had to do some custom code tweaking to get the main menu to also use the same mesh gradient background without feeling like it was transitioning to a different screen when going from the main menu to the game. And I wanted the poker hand reference overlay to feel like a proper “overlay,” so I gave that view a lighter material background and had it render directly on top of the game, allowing for the looping mesh gradient to still be visible but blurred behind the overlay. The effect this creates is <strong>a sensation that you haven’t left the game and that it’s still running in the background</strong>, you’re just in a temporal space above it momentarily.</p><h4>Text animation effects &amp; the “Play hand” button</h4><p>One more thing I really wanted to explore was <strong>dynamic text effects.</strong> I wanted to have the text that displays the poker hand and the text inside the “Play hand” / “Play again” buttons subtly pulse and animate for the entire duration that they’re visible. They’re UI elements that respond to your set of selected cards and indicate <strong>a sense of realtime, ephemeral feedback, so I wanted them to reflect that in some way with motion.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*Va_33OLx70NCrTrGCBItdQ.gif" /><figcaption>Example of the text wave animation effect that all the poker hand previews use. The text is using a different mesh gradient with brighter, more saturated colors that stood out nicely on the purple background with the help of a light shadow. This effect was re-used on all temporal text views in the app.</figcaption></figure><p>I asked Cursor to<strong> animate the characters glyph-by-glyph and have them subtly offset up-and-down in a looping wave pattern</strong>, which it managed to do after writing a <em>lot </em>of code. The wave amplitudes were either too high or the frequency was too fast, so I had to adjust this multiple times until it got to a point where I was satisfied with it. It now did <strong>a gentle continual pulse that nicely indicated their temporal nature through realtime feedback.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*UXrsTbGL58pADJeD-H_k8Q.gif" /><figcaption>The poker hand preview text wave effect resets every time it needs to update. Since the game is continually performing validation checks on the selected hand with the addition of every single card to the set, it needed to update its value and reset the animation on every valid hand detection on every card selection</figcaption></figure><p>The “Play hand” button was a great component to really explore fun motion and typography, since <strong>playing a hand is the primary action a player would take in the game over and over again</strong>. Submitting a valid hand is an opportunity to really sell the positive celebration effect, so I wanted to <strong>make this feel special</strong>. I iterated multiple times on both the success and failure state of submitting a poker hand until it felt just right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*U5hl_EJMRMGWCglIN0u_mg.gif" /><figcaption>The new mesh gradient was being used as an inner glow effect on the button, with a very subtle motion as it loops around the perimeter of the button. When submitting a valid hand, the “Play hand” button does a quick pop-and-scale animation before disappearing</figcaption></figure><p>I used the same yellow-ish mesh gradient that I was using on the text on the “Play hand” / “Play again” button border itself. I asked Cursor to <a href="https://uvolchyk.medium.com/sparkling-shiny-things-with-metal-and-swiftui-cba69c730a24">follow a specific tutorial</a> to implement this to generate a cool particle effect, but it wasn’t quite working right, so I <strong>had to manually hack it together step-by-step</strong>. I found a<a href="https://github.com/jacobamobin/AppleIntelligenceGlowEffect">nother great resource that recreated the Apple Intelligence “glow” effect</a> on the edges of your screen, which I asked Cursor to repurpose but apply to the “Play hand” / “Play again” buttons instead. After lots of tinkering with blend modes, mesh gradient colors, and blurs, I had a look that I was satisfied with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*qtJ3Ud9cCa3zYMle6tx9DA.gif" /><figcaption>The error animation for attempting to submitting an invalid hand was just a simple wiggle effect. I liked the simplicity of conveying this entirely through motion instead of adding additional text explaining why the submission was invalid — that should be clear from the selected set of hands itself</figcaption></figure><p><strong>If you stare really closely at the border of the button, the gradient colors on the button do change and subtly shift.</strong> I didn’t want it to be dramatic and exaggerated, so I liked the subtle implementation of this one. I actually was going for more of a glass-like look for the overall button but it didn’t quite fit with the visual theme of the rest of the UI, so I decided to keep what I had. This “Play hand” button would morph into the “Play again” button at the end of a game, which also re-used the same styles.</p><h4>Pulse effects</h4><p>One more detail I tweaked is to have the selected cards reflect their state more prominently beyond just a border color change to yellow. I added a subtle pulse effect on the rank and suit of the card where when they’re selected, they would <strong>continually scale up and down in a looping animation for as long as they’re selected.</strong> This was actually fairly easy to accomplish because the suit icons were all <strong>SF Symbols which had animations built-in to Swift</strong> (this is why I stuck to SF Symbols rather than finding or creating better assets for these).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*JeUqXvYsocLgbMuowa_tqA.gif" /><figcaption>Selecting cards also added a pulse effect on the selected rank and suit, reinforcing the ephemeral state of a card being selected and adding a second affordance with motion beyond just the yellow border glow</figcaption></figure><p>These looked really good. <strong>They communicated the selected state really well and I liked the gentle looping pace at which they were animating.</strong> I decided to re-use the same pulsing animation for the SF Symbols I was using in the “Play hand” / “Play again” buttons, namely the Play icon and the Refresh icon, both of which were also SF Symbols. I did have to do a fair bit of tweaking and fine-tuning to get the animation and timing to look right (and bash another twenty bugs along the way with animation sequencing), but once I had it all setup, it worked really well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*bT9YwQMmmkve0Dii9GjeDQ.gif" /><figcaption>The icons on the “Play hand” and “Play again” buttons were also SF Symbols, which made it very else to reapply the same pulse effects being used on the card suits here</figcaption></figure><h4>Metal shaders</h4><p>One thing I was really itching to do is add more metal shader effects. The <a href="https://developer.apple.com/videos/play/wwdc2024/10151/?time=1180">WWDC talk that I referenced multiple times in this project</a> talks at length about the cool effects you can make with <strong>Metal, a shader library built directly into Swift. I especially loved the ripple effect that responds dynamically to the exact spot on the UI that you touched. </strong>It’s such a nice way of recognizing input and providing instant feedback.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*0SxiHxWtIRvFqWe6zxFXTQ.gif" /><figcaption>An example of the metal ripple effect (<a href="https://www.youtube.com/watch?v=eXi6ITvqXoA">source</a>) I was trying to add to the cards. I love that it reacts to where exactly the touch input was detected and ripples out from that specific point</figcaption></figure><p>So I gave Cursor some reference examples and asked it to implement the code. <strong>Every single time it tried to do it, the cards simply wouldn’t render at all. When Metal shader effects are removed, the cards displayed, but when they’re applied, the cards were gone. </strong>This was driving me crazy, I tried several different workarounds to no avail. To make matters worse, <strong>Cursor kept gaslighting me into believing that the cards were indeed showing up because it’s debugging logs said so.</strong> We got into many back-and-forth fights here where I kept insisting that the cards weren’t showing up but Cursor kept insisting that they did. The joys of vibe-coding with AI.</p><p>After many hours of trying to resolve this, I had a wild hunch: this may be due to the material backgrounds I had applied on the cards. When I suggested this, Cursor agreed that it could be the main culprit (I’m not sure why it didn’t catch this by itself). I asked it to remove the material effect and give it a solid background fill, which it did and….still nothing! <strong>The Metal shaders were simply not working no matter what I tried.</strong> After several more hours, I gave up on this, attributing the issue to some<strong> weird way I had visual effects setup in my project that Metal didn’t seem to like</strong>. This was quite a big timesink to try and figure out without any resolution whatsoever. Disappointing, but not entirely unexpected.</p><h4>Final UI polish</h4><p>When submitting a played hand, I really wanted the <strong>score to tally up and update its number. </strong>This was also really straightforward to do, Cursor seemed to get it right away and ran up an animation whenever the score increased (after some tweaks by yours truly to the timing and duration). I also added the same<strong> text gradient on the score, but only for the moment when it’s actually counting up.</strong> For the rest of the time, I wanted the score to not be the most visible thing in the UI and let the focus be on the cards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*ay0uAOgEhL_kcZaCn98c3A.gif" /><figcaption>The score tallies up and the label updates to “New high score” when you cross your previous best. During the tally up animation, the gradient on the numerical score briefly updates to the yellow mesh gradient to increase legibility and draw attention to the score for that moment while it’s increasing before reverting back</figcaption></figure><p>I also wanted to make some styling changes to the main menu. I added the <strong>game title on the main menu </strong>and applied the same glyph-by-glyph character animation that the rest of the text was using. I also added a whole background where the suits of the card fall down in a trail at different rates, creating a rainfall effect. These also weren’t surprisingly difficult to do, I just had to tell Cursor exactly how I wanted these to behave.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i_P62gs89DOpB-xR80yMsw.gif" /><figcaption>The final main menu with the mesh gradient background and a view of falling ranks in the background</figcaption></figure><p>Lastly, I made some <strong>UI legibility updates to the view where you can reference all the playable poker hands.</strong> I updated the type styles, fixed some layout/spacing issues, and updated the transition animation when opening or dismissing the view. I also updated the preview cards to display accurate and helpful hints to subtly encourage the players to try making unconventional hands that are still valid.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLOH0zL-hfGdqxiNua2Ucw.gif" /><figcaption>The final Hand Reference View included some UI/layout updates as well as dynamic previews of the actual cards to quickly digest the valid hands, see an example, and view the ranking to plan and strategize around how to get the highest possible score</figcaption></figure><h4>Code complete…?</h4><p>I must’ve tweaked twenty other small UI details at this point, and I’m forgetting them all. <strong>What I do know is that my Github repo reached over 270 commits at this point</strong> (added across all the versions and iterations that I reverted to), and I was exhausted. I had been working on this project non-stop for many evenings and nights at this point, and I just wanted to launch it to the App Store. <strong>This mental exhaustion is something I didn’t quite account for when planning the original MVP.</strong> I just wanted to create cool UI effects and the fact that it all happens towards the end made it really difficult to push through it, especially when all the core logic of the game was breaking with every change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*auP6Tq4U6JCZSAWCLv1Elg.gif" /><figcaption>The final core gameplay loop after all my UI refinements. I had a cool mesh gradient background, animated text effects on the poker hand previews, better button animation states, and dynamic score updates all working together nicely. While not everything I wanted, I was happy with it to call it here for the MVP.</figcaption></figure><p>I wanted to add so many more things: <strong>subtle 3D rotation animations for the cards (similar to Balatro), better animations for when cards fall into the view and new cards come in, updated loading and game over states with custom transitions, themed cards for different deck types, light mode &amp; dark mode support, maybe proper difficulty settings</strong>, etc. But at this point, I honestly felt like any net new thing I added would completely break the build and cause more issues. It didn’t help that Cursor’s AI models started hallucinating at this point and losing context all the time. <strong>Every day, I was just happy to have a stable build without bugs that wasn’t crashing</strong> and was actually just working as expected. <strong>I decided to call it here and ship this as the MVP to the App Store.</strong> I was pretty satisfied with where the design quality was, especially given that I had no plan or idea for the entire app or interface at the start and just made it up as I went.</p><h3>Chapter V: Releasing to the App Store</h3><p>I kept finding the odd bug here and there that I pushed fixes for, but aside from that, the app was ready for primetime. Now I just needed to put it on the App Store. I had heard many horror stories of Apple’s app review process and how you can get flagged and removed for the most minor of things, so I wanted to be thorough. <strong>I asked Cursor to do one final check of the code for things that might get flagged by Apple and proactively resolve them</strong>. Cursor came up with a “Launch readiness checklist” of which there were several sections, one of which was “Technical Reliability and Code Quality” with several sub-sections.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x0voRRO_Xf5J9GGSyfxdkw.png" /><figcaption>My initial prompt and Cursor’s result for “Technical Readiness &amp; Code Quality” which had many, many sub-sections within it (the first one is shown here)</figcaption></figure><p>I asked Cursor to run through the entire codebase and cross-reference it against the things that don’t adhere to the guidelines in technical reliability and code quality, and uhh, <strong>nearly panicked when I said the entire app would likely get rejected due to how it doesn’t adhere to Apple’s Swift best practices.</strong> Cursor found that two of the main files in the app, the view and the view model, were several thousand lines of code and suggested breaking them up into smaller files to optimize performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GuMsaej8Z2STKoOvZR8Kig.png" /><figcaption>This is only 20% of the output of what Cursor gave me when I asked it how it would update the code to adhere to Apple’s SwiftUI best practices to minimize the chance of any rejections from the App Store. It was…a lot. I had a sinking feeling in my stomach as it kept going through this entire list</figcaption></figure><h4>The refactoring nightmare</h4><p>A word of caution when it comes to refactoring code if you don’t know how to program and are relying on an AI to do it: <em>saddle up</em>. This process is an absolute mess. I understood what refactoring meant at a high level, but had never done it myself, of course. And try to empathize for a second with what the AI is doing here. <strong>It’s taking a codebase that it’s completely lost context of in terms of what the goal is and what we’ve done so far, and is trying to split up logic into smaller files. Of course it’s going to break. It broke, a lot.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zhmw8l2c9RVgRs3gViEsGA.png" /><figcaption>As is evident by my incredibly nervous prompts, I didn’t have any confidence in this refactor ensuring that everything in the build remained as-is. At least Cursor gave me a mitigation plan of things it would try to do and ensure that nothing breaks in terms of functionality and UI. After much more prompting where Cursor reassured me that it would try not to break anything, I took a deep breath. I decided to trust it and proceed because it was my only option to get this thing up on the App Store without getting flagged for random things.</figcaption></figure><p>My first few attempts here completely failed. I asked Cursor to give me a detailed implementation plan for the refactor, which it did, and then asked it to implement it. Of course, after implementing it, it had some<strong> 50–60 build errors that I had to get it to resolve one-by-one. </strong>And then when it was finally able to render the UI and successfully build, <strong>the app looked nothing like it did before. The mesh gradient background was gone, the cards looked completely different, I wasn’t able to select cards. Basically, everything broke.</strong> <strong>I had to revert back to an older build and ask it to implement changes one step at a time</strong>, but it’s sort of tough to do with refactors because you’re moving entire blocks of code logic across files and you have to update multiple files at once.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kSz6wbyZfFPBM4r7dfaxEg.png" /><figcaption>When Cursor kept running into debugging loops or kept breaking things with the refactor, I took it upon myself to find the issues and started asking it only focus on specific lines of code, which worked way better. A big learning here is that when refactoring the entire codebase, the LLMs often don’t know what to hone in on, so it requires a lot of prompting from you, the human, to tell it where to look to fix the problem.</figcaption></figure><p>I got way more explicit with my prompts. <strong>I highlighted blocks of code and told Cursor to move a specific chunk of logic, like the UI for how card views are drawn, to a separate file as Step 1</strong>, and then checked if the build worked. If it didn’t, I resolved the bugs until it looked the same as it did before. Then I asked it to move another chunk of logic, like how connecting lines are drawn, to a different file as Step 2. Then checked if everything worked as expected. I kept going like this and had a rough sense of what pieces of code I needed to move outside the main file until I got to a point where the main file was only rendering views and all the logic had been offloaded to different files.</p><p>I felt like I was in the matrix as I was doing this, fully knowing exactly what each chunk of code was doing and how to separate it without leaving any leftover scraps and making sure the identifiers and calls were working as expected so that the correct calls would still be made. This was a strange feeling. <strong>I didn’t write any of the code myself and didn’t really understand the details or the language, but I knew enough about it to move entire pieces around like some wizard.</strong> It felt like I was an urban planner for the project structure itself, offloading and moving things around while making sure the whole thing still worked and made sense.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JW9YtMENKtwmgUvhE7_AXw.png" /><figcaption>As I kept going through each file in the codebase and refactored it, I kept checking against the iOS Launch Checklist to see whether the most critical bugs that would get my app flagged in the App Store review process were fixed or not. I put 100% of my energy into just focusing and fixing these issues</figcaption></figure><p>Doing this took…forever. But it was the only way I found to make sure Cursor doesn’t completely break my app or get me from flagged by Apple when launching it on the App Store. <strong>This wasn’t the first time in the project I had attempted a refactor. I had noticed previously that it was getting really bloated, so I had unsuccessfully attempted refactors in the past with dreadful results where the whole app kept crashing.</strong> I panicked and quickly reverted to older builds at the time, but this time, I felt like my back was against the wall. <strong>I had no choice but to refactor it in order to launch, no matter how painful it was.</strong></p><p>As I kept going through the files, I kept asking Cursor to cross-check against the “Technical Reliability &amp; Code Quality” section of the Launch Readiness Checklist and tell me if I’m good to go. It kept finding more issues that it didn’t tell me about before, which I found slightly annoying, but I fixed those too anyway. Finally, I asked it if there were any critical, launch-blocking issues that would put me on Apple’s naughty list. It told me to remove some print statements and console debug output, which I did, and at last, it said the project was in a good place! <strong>You would not believe the sigh of relief I had in this moment. I knew I could finally launch the damn thing.</strong></p><h4>UI and layout scaling</h4><p>There was one more issue in the iOS Launch Checklist that bothered me on a personal level which I wouldn’t be able to live with if I had launched with it, and that was the layout scaling. You see, when I was building the UI, I was only previewing on my iPhone 15 Pro, so it always looked good on it. As soon as you start previewing on smaller devices like the iPhone 13 Mini or the iPhone SE, the layout starts getting clipped. The score gets cutoff by the safe area at the top and the “Play hand” gets cutoff by the bottom edge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iK8NXXxN9F51xOxAtGzJAQ.png" /><figcaption>This is what Poker Slam looks like on an iPhone SE. This is the oldest Apple device (it still has the Home button!) that currently support modern iOS versions, so you could technically run the game on it. Fixing the layout for this device specifically would require rewriting the entire game layout, so I decided not to deal with this, especially because the device will likely soon be obsolete anyway</figcaption></figure><p>I had to tell Cursor to apply dynamic layouts on this where the buttons and UI would scale to resize accordingly, but this was trickier than expected. The cards all had to be a fixed size due to the way the connecting lines were being drawn using the GeometryReader() function, so <strong>I couldn’t dynamically scale the cards without completely breaking how connecting lines worked</strong>, and I really didn’t want to break anything, especially after that tedious refactor. So I decided to keep the cards a fixed size on all devices (which looks really wild on an iPad), but scaled the rest of the UI.</p><p>I intentionally had some empty space left above and below the card grid where the poker hand names and the “Play hand” button appeared and disappeared, and<strong> it took a <em>lot </em>of work to make sure that the layout of the card grid didn’t shift while these UI elements were showing up and going away</strong>. I was faking an empty container that maintained the same amount of padding above and below the card grid regardless of whether or not those elements were shown. And I really didn’t want to run into those bugs again, so the layout does still clip on the smallest resolution iPhone that can run this app, the iPhone SE.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*95hq4PeLGBGwu7iwpUDEYg.png" /><figcaption>While I wasn’t planning to include iPad support, the game technically runs on an iPad because iPads also run iOS apps. The layout is very whack on an iPad and doesn’t look good at all. Fixing the layout here would also require rewriting the entire layout engine which would cause issues with the animations and how connecting lines are drawn between cards, so I also decided to live with this, despite how much it hurt to ignore it</figcaption></figure><p>But I accepted this tradeoff. You could technically still play the game on it and view your score, just the “Play hand” button got cutoff weirdly at the bottom. And I honestly don’t know who has iPhone SEs anymore, so this was fine by me. There were a few more small accessibility and minor issues in the launch checklist that Cursor recommended I check out, but none of them would get me blocked by Apple, so <strong>I only focused on the launch-critical things for now because I just <em>really </em>wanted to ship this out and be done with it.</strong></p><h4>App Store Connect</h4><p>The main thing I needed to do to actually distribute the app is, well, have an Apple Developer account. So I paid the $99/yr for that and waited for it to activate. In the meantime, I loaded up the App Store Connect page, which is where we release the app to the App Store. I looked through what was needed and started prepping the launch assets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9wKfrwRrLBV1Wh6qY7jQLw.png" /><figcaption>The App Store Connect page for Poker Slam that you can make once you have an Apple Developer account. I realized I had to make a ton of launch assets, write marketing blurbs, add privacy &amp; security info, etc. This is a part of the process Cursor can’t quite help much with, so I had to do a ton of googling to work my way through this process. I did get Cursor’s help to write a lot of the descriptions and details of the app though</figcaption></figure><p>I had an app icon that I was using to preview local builds that I liked, so I decided to keep that. I also added a launch image that displays when the app is first opening. along with several App Store images that describe what the game is and how to play it along with an app preview video. Both the app icon and the launch image needed to be in the actual project build, so I added them to the Assets.xcassets file of the XCode project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*tJMtlfqf99MCafrI2Etfrg.png" /><figcaption>I kept the Poker Slam app icon pretty simple, using the suit colors and the purple background</figcaption></figure><p>Outside of the app icon and launch image, there’s just a few more assets needed for the App Store Connect page itself, namely App Store Screenshots and App Previews. So I quickly spun those up using actual screenshots and screen recordings from the build because I didn’t have any design mocks. Beyond that, there is so much stuff to fill out on the App Store Connect page, it’s crazy. Marketing blurbs, descriptions, age restrictions, privacy policy, support page links, contact info, etc. I went through all of them and used some shortcuts to quickly generate links for some of the legal requirements and get working links ready.</p><h4>Code complete 🎊</h4><p>To distribute to App Store Connect via XCode, you have to create an archive of your build. Once the app icon and launch images were in, that was it. This was the build that was going to launch. Any other changes would have to come in a future update with a different build number. So…this was it.<strong> I was officially code complete! This was also a weird feeling, knowing that I wouldn’t be adding any new features to the launch version and that this is the version of the game that would be launching to users.</strong> I did some last minute QA’ing of specific scenarios you could get into and created the launch build for the archive.</p><p>The archive process runs a validation check, which is the point at which it would flag any issues or warnings to you. Thanks to my torturous decision to painstakingly refactor the entire codebase step-by-step, <strong>I didn’t run into any major problems here and everything validated correctly</strong>, which I was happy about. Now all I had to do was select the build in the App Store Connect page and hit “Submit for review.” That was it. Apple would review the app in the next 2–3 days and approve or deny it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nEj0GCxvMGTXM5n-l_9c2A.png" /><figcaption>Poker Slam on the App Store! <a href="https://apps.apple.com/us/app/poker-slam/id6745245227?platform=iphone">Here’s the link</a> if you’d like to download it (open it on your iPhone)</figcaption></figure><p>Within 24 hours, I saw that the build was approved. I checked the App Store by searching for “Poker Slam” and there it was, with my app icon and all my assets and my name on it. <a href="https://apps.apple.com/us/app/poker-slam/id6745245227?platform=iphone">Here’s the link</a> if you’d like to download it (open it on your iPhone). <strong>It was a proud moment. My first app, fully vibe coded from idea to App Store entirely with Cursor.</strong> I downloaded it and send it around to some folks to check it out, and was pleasantly surprised to see that it ran without any major bugs or issues. Every time I saw a friend or family member download it and try it out, I was nervously expecting the build to crash at any moment or at the very least, see some weird visual glitch where cards weren’t filling in the gaps properly, but I couldn’t believe that everything was working flawlessly. I was so relieved.</p><p><strong>What I loved the most was seeing people actually enjoy it and replay it again and again.</strong> I assumed people would try it out once or twice and give it up, but my own family got obsessed with the game where they were trying to best each others’ high scores, which was wholesome to see. My mom herself said it was addicting and that she was trying to cross the 800-threshold of high scores. This was particularly validating to me, because <strong>I really wanted the game to be accessible and approachable by anyone, even those who weren’t familiar with poker or games in general</strong>. And my mom is a perfect candidate for that, so I consider this a huge success! 🙌</p><h3>Chapter VI: Lessons learned</h3><p>So let’s recap the goals I set for myself at the beginning of this wild adventure and see how we did, shall we? Here’s what I had at the start of this post in Chapter I as my goals with this project:</p><ol><li><strong>Create an end-to-end product </strong>that I could release to the App Store</li><li><strong>Learn how to work with AI models</strong> to get better at prompting it in order to get the outcomes I wanted</li><li><strong>Understand SwiftUI better</strong>, specifically when it comes to the frontend implementation: shaders, effects, text animations, gradients, etc.</li></ol><p>Check, check, and check. I got to do all of this and learned, sometimes the excruciatingly hard way, what’s difficult and what’s not. AI models can be very moody and need a lot of explicit prompting or rules to make sure they can continually keep working on the same codebase without losing context. <strong>Visual effects and animations are a massive pain</strong> but workable if you can provide reference code and are willing to fiddle or fine-tune the output to tweak the output to be exactly the way you want it to be.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nB3DGMNzGqbQoMFhjGqwcQ.png" /><figcaption>We…did it?! I’m not sure if Cursor’s LLMs are “proud” of the work, but I am! Image created with GPT-4o</figcaption></figure><h4>Non-goals achieved</h4><p>I also want to point out that there were just so many things that weren’t part of my original goals with this project that I ended up learning along the way which I’m massively thankful for:</p><ol><li>Logically breaking down your final vision into chunks that you can <strong>prompt Cursor to build iteratively</strong>, one major chunk at a time</li><li>How to <strong>setup a project file in XCode</strong> with iOS &amp; Swift best practices</li><li>How to get AI models to <strong>refactor the entire codebase properly </strong>without breaking anything and stepping through it manually by guiding it</li><li>How to <strong>create a source of truth rules file</strong> for Cursor to reference so that it doesn’t constantly rewrite your files or create new one-off files</li><li>How to <strong>maintain robust project documentation </strong>with a readme file, a technical documentation file, and a technical architecture file that Cursor constantly keeps updated so that if we ever completely lose context, it can reference those files to catch up on what we’re doing and what we’ve done so far</li><li><strong>How to use Git</strong> and manage the project’s state with version control so that we can easily revert to an older build when things go wrong</li><li><strong>How to use Github</strong> in conjunction with XCode and continually commit updates in small batches on a dev branch and pull it into the main branch to keep a stable build at all times</li><li><strong>Learn coding in Swift </strong>for specific UI effects: I ended up learning a lot of Swift, especially when it comes to proper syntax and structure for UI effects on simple buttons and layouts by manually overriding them in XCode whenever Cursor was failing with simple design tasks</li><li>How to <strong>prompt Cursor to follow coding best practices</strong> like separating concerns, using test driven development, debugging with console print statements, handling compile errors, build using the Model-View-Viewmodel (MVVM) architecture from the start</li><li>Most importantly, <strong>knowing when the code is over-engineering something</strong> (like when it writes a python script for a combinatorial solver that runs overnight) and telling it to not proceed down this path and do something else instead</li></ol><p>I feel like I’ve had a trial-by-fire of learning by doing when it comes to all of the above, and <strong>I feel so well equipped going into my next project</strong> of what to do and what not to do. I won’t need to spend time fighting with version control and basic project setup like I did this time. I won’t need to deal with AI models going haywire because I’ve got a good system going for how to setup the project files now and if needed, can also guide the models through an intensive refactor at any time in the project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28O-jsAVbTkOteZiYLQrNA.png" /><figcaption>I feel way more confident vibe coding something more complex in my next project. Image created with GPT-4o</figcaption></figure><h4>Retrospective</h4><p>On a scale of 1 to 10, I would rate the difficulty of this project as a 7/10. Someone less technically inclined or who would get frustrated easily at roadblocks may rate it a 9/10. I had done a fair bit of prototyping in the past using code-heavy tools like Framer Studio and had some web development experience, so <strong>I wasn’t put off by the constant barrage of technical issues and bugs.</strong> One thing that helped a lot is just being able to directly ask Cursor how to solve the issue, which helped almost every time.</p><p>Still, there were many moments where I just wanted to throw Cursor off a cliff or yell at it for not understanding the basic premise of what we were trying to do. The thing that kept me going through all those difficult moments is, as cheesy as it sounds, <strong>the joy of creation.</strong> <strong>I loved being able to bring an idea to life all by myself without having to justify the “why” being a design decision to a room full of non-designers who don’t <em>get</em> design</strong>. If I wanted a an animating gradient, I could add an animating gradient. If I wanted connecting lines to not overlap and have a clean look, I could spend the necessary hours or days doing it. If I wanted text to animate in a specific way, I could tweak it until it was just right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yw6eZuLi7vRgOSPNVSt9nA.png" /><figcaption>Bringing your idea to life, all by yourself, has a special appeal to it. Image created with GPT-4o</figcaption></figure><p>The #1 thing that really kills the joy of design for me in my day job is <strong>having to explain why and how every single micro-detail in a design ladders up to some made-up acronym someone created seven years ago and mapped a bunch of cost metrics to it. </strong>I get that we have to do it because design ultimately serves business goals, but as I get more senior, the more time I spend doing that and the less time I spend designing. I often question what I’m even doing with my life when I’m spending hours making a slide deck explaining how using gradients for a heatmap can help us increase efficiency through visual clarity of volume &amp; density. Why spend the time doing that if you can just directly get to the outcome you want in that time instead by just directly implementing the design?</p><p>That was the main driving force for me to push through all the setbacks and get to the end. There are specific lowlights that I can recall which made my life very difficult:</p><ol><li><strong>The system for validating poker hands was a huge pain to get working the way I wanted</strong>. I wanted players to be able to select a hand in any order as long as they were adjacent. You could select a 5 in the middle, a 3 above it, a 7 below it, a 4 diagonally adjacent to the 7, and a 6 diagonally adjacent to the 3. This hand needed to validate as a <em>Straight</em>. And you needed to be able to choose these cards in any order. It took a lot of playtesting, manual QA’ing, and repeated iterations to get it to work correctly with the behavior I wanted</li><li><strong>Getting visual effects and animations to display how I wanted them to caused a ton of headaches.</strong> Cursor kept gaslighting me telling me that animations are working as expected, but of course, I wasn’t seeing them visually render. The various effects and libraries conflicted with each other in unexpected ways that made something break in the code that Cursor wasn’t able to catch. This is something to watch out for when asking it to follow sample code from different sources</li><li><strong>The AI models tend to go too deep into debugging rabbit holes. </strong>Too often, they’ll start with good intentions to figure out why something isn’t working as expected, and then start creating debugging logic and print statements to identify the issue. It will often rewrite or erase entire chunks of code (which should be a red flag) that had nothing to do with the original issue. More often than not, it’s best to just start over</li><li><strong>The refactor really tested my patience.</strong> I had to at one point start telling Cursor how to setup the project properly, to the point where I was extremely explicit about telling it to create a custom <em>SharedUI.swift</em> file to host all the animations, a <em>GameStateManager.swift</em> file to handle all the game states, and what pieces of code logic to move to the main <em>GameViewModel.swift</em> file. I myself had to understand how the project <strong>should</strong> be structured<em> </em>in order to tell Cursor how to structure it</li><li>Learning to adapt to the moodiness of the AI models was also really frustrating. I learned that <strong>ChatGPT 4o is great for high level planning, Claude 3.7 Sonnet is good for general implementation and execution, and Gemini 2.5 Pro is best at debugging or injecting specific targeted fixes</strong> into the codebase. Each model has its strengths, and it took a lot of trial-and-error to leverage each one’s strengths to what I wanted to do.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Q4ln_U3p24yvrOoMX-YFQ.png" /><figcaption>AI models aren’t great at…many things, including refactoring, dealing with UI &amp; animation bugs, and having the memory of a goldfish in general where they constantly lose context. Image created with GPT-4o</figcaption></figure><h4>Vibe coding revisited</h4><p><strong>So after all this, would I still recommend vibe coding? The answer is a resounding YES.</strong> You will be so impressed at your own ability to bring an idea to life that the old way of product development is going to seem so archaic and boring. You’ll have to put up with lots of technical problems, but if you’re willing to fight through it, I truly believe it’s in your best interest to learn it.</p><p>It almost doesn’t matter <em>what </em>you make. Make something. Make <em>anything. </em>A silly card game or a calculator or a clock that visualizes your calendar. <strong>The product is just an output, the most important thing is to experiment with the process of creating something and learn from it.</strong> You don’t even have to ship your thing, you can just throw it away and show no-one.</p><p>I believe that <strong>AI agents, especially when applied to product development, are an existential threat to the traditional roles of of Product Management, Product Design, and Software Development.</strong> Anyone with capital can get 60–70% of the the way there by just having one person vibe code a prototype instead of investing thousands in a seed round with a fully staffed team in a startup. The whole landscape of venture capital and bringing MVPs to life is about to change dramatically, especially as AI agents continue to get better with proper inference and reasoning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EYu0GvMjumntp1he2s_PYw.png" /><figcaption>Like it or not, the AI disruption is coming for product development. Image created with GPT-4o</figcaption></figure><p>But here’s the best part: those product roles are already perfectly equipped to leverage the heck out of AI agents <em>right now.</em> All disciplines benefit greatly from being able to build stuff with AI agents:</p><ul><li>To effectively build with AI agents, you need to be able to <strong>deconstruct a vision into specific requirements and built iteratively</strong>. This is literally what Product Managers and Product Designers do every day at work. You’re creating a vision, reverse-engineering your way back towards a MVP, and then building towards the final vision</li><li>The<strong> most effective AI prompts are the ones convey concepts in atomic design structures</strong>: an atom to a molecule to an organism to a template to a view, e.g., in my game this would be the base card style to the various states of a card (selected, unselected, ineligible) to the set of connected cards to the entire card grid itself. Designers already think like this when creating Figma components for their work, it’s just translating this to AI prompts now</li><li>Product Managers spend days writing PRDs and documentation. This is <em>exactly </em>what <strong>Cursor needs to reference in order to understand what we’re even building and why</strong>. Put this in a <em>rules.mdc</em> file and you’ve got an AI agent that never loses context and always understands what you’re doing. PMs are also very effective at making tradeoff decisions when it comes to value derived from a specific feature versus the time or effort spent building it, so they can quickly write off low-value ideas and move on to the highest-impact ones</li><li><strong>Software engineers can greatly accelerate their workflows</strong> by offloading all the tedious tasks to AI and focus on the more important complex stuff like authentication, payment authorizations, app infrastructure, information security, and data privacy that you wouldn’t want an AI to hack through. The entire frontend can often be handled by the AI agent if you’re explicit with what your ask is</li><li>Engineers also spend a lot of time writing detailed technical specs and architecture docs about how they would go about implementing a complex new feature. Well, you can <strong>avoid 90% of AI pitfalls with this knowledge by knowing exactly what to do when you see something go wrong</strong>. You can either manually fix it or have the AI do it for you. Refactoring also becomes way more seamless if you can just tell the AI where to move all the right pieces of code to</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1zZjZIixdVxFdnX5ddttWA.png" /><figcaption>Anyone with an idea can, and should, vibe code to prototype them and learn! Image created with GPT-4o</figcaption></figure><h4>What’s next?</h4><p>If you’re wondering whether I’m going to continue working on and improve the game, the answer is <em>maybe. </em><strong>I’m pretty happy with the MVP I launched and was happy to see that there weren’t any gamebreaking bugs in the 1.0 release.</strong> Friends &amp; family have been sending me feedback to add or improve certain things. The #1 feature request from every single person so far has been <strong>better tracking of high scores</strong>, which I had previously omitted because I wasn’t sure if people were even going to play this thing. This is the one and only new feature I added to the game after the 1.0 launch, where you can now <strong>see your high score on the main menu</strong>. As for the other feature requests, they may have to wait a while. I’m going to take a little break from staring at poker hands for a bit and will maybe come back to it with new gameplay mechanics and features soon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LgyxebQUJsfOHZbod0nTUA.png" /><figcaption>The only post-launch update I shipped was to add high-score tracking, the #1 most popular feature request</figcaption></figure><p>In the meantime, I’ve got a Notion doc with 50 more ideas for things that I can vibe code. Throughout this project, I randomly spun up new XCode projects to quickly experiment with prototypes to see if something was doable. Some of them were very promising, and I had to resist the temptation to abandon Poker Slam to work on that instead. So now that this game is done, <strong>I’m going to go back into tinkering with some ideas to create something even cooler </strong>(and possibly more ambitious?) with my newfound skillset for how to tame Cursor into doing what I want. Keep an eye out for more info soon!</p><p>In the meantime, feel free to reach out me on <a href="https://bsky.app/profile/akhil17.bsky.social">Bluesky</a> or email me at dakinedi@gmail.com if you want to provide feedback about Poker Slam, send me your high score, want to ask about anything I’ve mentioned relating to design or vibe coding, or have any questions in general. The <a href="https://github.com/akhil-17/PokerSlam-3">final GitHub repo for Poker Slam</a> is also available if you want to peek at any part of the code. I hope this has inspired you to give vibe coding a shot, and a sincere thank you if you made it all the way to the end here. Cheers! :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ff57588ab41" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Pt. 1/2] Vibe coding my way to the App Store]]></title>
            <link>https://medium.com/@a_kill_/pt-1-2-vibe-coding-my-way-to-the-app-store-539d90accc45?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/539d90accc45</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[poker]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Tue, 27 May 2025 01:26:59 GMT</pubDate>
            <atom:updated>2025-05-31T06:27:18.292Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mpBmu1d0pmSZmFZIhGZl4A.png" /></figure><p>Part 1/2 of deep-dive case study on how I prototyped, built, and shipped <a href="https://apps.apple.com/us/app/poker-slam/id6745245227?platform=iphone">Poker Slam</a> to the iOS App Store using Cursor.</p><p><strong><em>Part 1</em></strong> of this series (this post) covers:</p><ul><li>Chapter I: Intro to vibe coding</li><li>Chapter II: The path to prototyping</li><li>Chapter III: Building the game</li></ul><p><a href="https://medium.com/@a_kill_/pt-2-2-vibe-coding-my-way-to-the-app-store-1ff57588ab41"><strong><em>Part 2</em></strong> of this series</a> covers:</p><ul><li>Chapter IV: Refining the UI</li><li>Chapter V: Releasing to the App Store</li><li>Chapter VI: Lessons learned</li></ul><p>If you don’t have time to read the full blog post, check out the abridged video version:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F1089278854%3Fapp_id%3D122963&amp;dntp=1&amp;display_name=Vimeo&amp;url=https%3A%2F%2Fvimeo.com%2F1089278854&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F2021681233-1450e09ee894484f61cb3502d801a6f95c407bb33a2f1f1cb395cafc2684ca1f-d_1280%3Fregion%3Dus&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1080" frameborder="0" scrolling="no"><a href="https://medium.com/media/47e674fc4503bbcef5e090137a700b36/href">https://medium.com/media/47e674fc4503bbcef5e090137a700b36/href</a></iframe><h3>Chapter I: Intro to vibe coding</h3><p><a href="https://apps.apple.com/us/app/poker-slam/id6745245227?platform=iphone">Poker Slam</a> is an app I designed, <em>vibe-coded, </em>and launched on the App Store. It’s a puzzle-strategy card game where you create poker hands by connecting adjacent cards on a 5x5 card grid and score based on the rarity of the hand you just played. New cards appear until the entire deck of 52 cards has been exhausted or you run out of valid poker hands to play.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*RGHIzDHimy_4gOtK9eP86w.gif" /><figcaption>Poker Slam’s core gameplay loop: selecting adjacent cards to form poker hands and playing them to score</figcaption></figure><p>This is the first app I ever launched and this post details the actual process I went through, all the way from the initial ideation until the final implementation and releasing it to the App Store. <strong>The core app took roughly 10–15 hours to build</strong>, but if you include all the time experimenting with ideas, prototyping various interaction &amp; gesture techniques, retrieving old builds from Git due to AI mishaps, and debugging how effect libraries and third-party packages completely break the app, the <strong>total time it took to build stretches to somewhere in the range of 60–80 hours</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ofZj2gOye-EWrEEPn7eXzw.png" /><figcaption>Only ~20% of the total time I spent on this project was on building the game that eventually launched to the App Store. The rest of the time went to various other timesinks</figcaption></figure><p>This post focuses on the design process of me working through an idea with an AI partner. It’s <strong>not a technical breakdown of AI prompt engineering</strong> and doesn’t get into the weeds of code structure, syntax, or overall coding best practices. I’m mostly going to f<strong>ocus on how I worked with Cursor to bring my idea to life </strong>and all the highs and lows of what that experience entailed, along with an exhaustive breakdown of what I learned from it at the end. Strap in!</p><h4>Why even do this?</h4><p>Vibe coding, especially when you don’t have any background whatsoever programming in the language that you’re writing in and no past experience building native apps, can be a bit nightmarish. <strong>You spend 30% of the time prompting the AI for code that works and 70% of the time debugging various errors that show up due to the AI constantly losing context about what you’re even doing.</strong> Often, the AI will implement random features that you never asked for, causing even more problems when it breaks things that were working perfectly fine before. Before we dive into what I built and how I built it, it’s worth asking <em>why</em> someone would even set out on this fool’s endeavor.</p><p>The answer to me is very simple: <strong>it enables you to do something that you weren’t able to before</strong>. For over a decade now, the way I brought my ideas to life were with mockups in design tools, interactive prototypes made in prototyping tools, and slide decks made to sell my vision and convince key stakeholders that it’s a problem worth solving. Now, I could bring my ideas to life much faster by just building some MVP of it myself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cMa3N5UlnI_zOjHCZtsMGw.png" /><figcaption>For anyone with an idea, AI coding tools are the magic wand to bringing their vision to life to validate if the concept is even working. The best part is that it can all be done solo, without needing to convince others to pursue your idea and without needing to deal with budgets or cost constraints. Image created with GPT-4o.</figcaption></figure><p>I’ve dabbled in XCode storyboards in the past to prototype apps and had a beginner-level understanding of programming in my brief stint as a web developer, but <strong>I’ve never actually been able to code and program an end-to-end product before</strong>. The recent explosion of AI coding tools lowered the barrier to entry for building apps where the <a href="https://medium.com/towards-generative-ai/english-is-the-new-coding-language-case-studies-of-gen-ai-tools-built-with-zero-code-852a59b1106e">programming language is now English</a>. If you can describe it in words, you can build it. Don’t understand obscure syntax requirements or complex algorithmic loop functions? Not a problem, just describe the output you want and the tool with handle the coding. That’s the promise, at least. <strong>Why would I <em>not </em>take advantage of a moment like this, where we’re on the brink of possibly the largest technological leap forward for how products are built?</strong></p><p>The code won’t be perfect, but that’s not the point. Many tenured programmers scoff at the AI code output as being too hacky or not following programming best practices, but I liken this to the same reaction that professional artists had when everyone was putting out AI art they “created” in Midjourney or DALL-E a few years ago. The <strong>art was entirely derivative, lacking any soul or substance and devoid of any meaning</strong>. To the artists that create actual art, that’s the whole point of <em>why </em>they make art, the paintbrush and canvas are just tools they’ve mastered over many years to achieve that outcome.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nt28xdqHxe-oniPfl_RNqA.png" /><figcaption>In its current state, AI can make some decent things, but needs a human’s intention and vision to truly make it feel like it was crafted for other humans. AI has no idea what it’s making or why it’s making it. That has and will always come from the creative expression of ideas from humans. Image created with GPT-4o.</figcaption></figure><p>A common Joe could now bypass years of patient refinement to their brushstrokes or color mixing and directly see their vision realized by typing a few short phrases in under a minute. Are they artists? Not really, but to an untrained eye, <strong>they’re spitting out a deliverable in the same format as an actual artist on faster timelines</strong>. It’s not going to be anywhere as good as what an actual artist can create with intent and purpose, but for a good chunk of the use cases, that output is deemed “good enough” by the market.</p><p>The same theory translates to vibe coding. <strong>I wouldn’t call myself a developer just because I launched something to the App Store</strong>. I only understand the code for my project at a high-level based on what each file and code block is responsible for executing when it compiles, I don’t know all the details of how it’s doing what it’s doing or why it chose sequence the actions it in a very specific way. If anything, <strong>I’m more of a project architect, specifying how the end product should behave and fine-tuning the experience as I go</strong>, continually adding and removing things based on how desirable or distracting they are to the goals of the product.</p><h4>What was I trying to achieve?</h4><p>Before starting with what I wanted to build, <strong>I started by asking why I’m even doing this</strong>. To me, this was less about the final output and more about the process of learning how to build something. I had very specific goals:</p><ol><li><strong>Create an end-to-end product</strong> that I could release to the App Store</li><li><strong>Learn how to work with AI models</strong> to get better at prompting it in order to get the outcomes I wanted</li><li><strong>Understand SwiftUI better</strong>, specifically when it comes to the frontend implementation: shaders, effects, text animations, gradients, etc.</li></ol><p>#3 was primarily inspired by my ongoing frustration working in tech companies for over a decade as a Product Designer working on native iOS apps. I would often have whiplash when I see Apple reveal <a href="https://developer.apple.com/videos/play/wwdc2024/10151/">cool stuff in WWDC</a> and then excitedly share it with my iOS developer, only for them to respond with some version of “<em>But we can’t do that</em>” along with some lengthy technical explanation of why it would take<strong> 4–6 weeks of dev time to animate characters in a text string</strong>. Transparently, I was a bit tired of needing to rely on an developer’s personal desire to get better at implementing cool UI and wanted to see if AI can bridge that gap between design and development.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vAjh3CgBvtzNYkrBtbcCpQ.png" /><figcaption>The classic dilemma between Design &amp; Engineering: Design always wants to push the technical boundaries of what’s possible with new innovations, but the codebase at most companies isn’t set up to handle brand new platform capabilities without breaking a dozen things somewhere else. Image created with GPT-4o</figcaption></figure><p>This is also what drove the decision to build this project as a <strong>native iOS app in Swift.</strong> You can build <em>anything</em> when vibe coding, be it a web app with React deployed with Vercel, a Python script that automates database computations, a native Android SDK written in Compose, or even just a plain old HTML/CSS website (I’ve used AI a lot to optimize tedious tasks on <a href="https://akhildakinedi.com/blog/">my personal blog</a> that would otherwise require manually editing 15+ WordPress files). I chose to build a native app in Swift because:</p><ol><li>My work as a designer in over a decade has primarily been on mobile apps and <strong>I understand mobile design requirements &amp; interaction patterns the best </strong>out of any available platform</li><li>Native apps get you access a lot of interesting stuff that you can’t quite get with a web app like <strong>access to the device’s accelerometer or precise location </strong>with a robust permissions framework (which I didn’t use in this project, but it opens up the possibility for future projects)</li><li>Web apps require you to design for keyboard &amp; mouse input as the primary interaction method. While touch gestures can be implemented, it requires integration with external libraries and you’re <strong>limited to what they allow</strong> when it comes to pushing the boundaries of visual effects (along with a slew of performance and latency issues due to browser &amp; compatibility problems)</li></ol><p>Given all of the above, I knew that writing a native iOS app in Swift and releasing to Apple’s App Store would be the best path forward for my goals.</p><h4>How did I set this up?</h4><p>Getting started with vibe coding an iOS app isn’t terribly complex. You have to use XCode, Apple’s IDE for iOS apps, in conjunction with a tool like Cursor to directly edit the files in XCode. <strong>Both XCode and Cursor need to be running simultaneously.</strong> You reference the same project files in both — Cursor modifies the files while XCode tries to build and compile it (along with showing you a preview, possibly the most helpful feature). There are <a href="https://www.youtube.com/watch?v=1whvTugenL4">tons of YouTube tutorials</a> on how to set this up with your project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*06fRURBNhlOfwlbA6_Jdlw.png" /><figcaption>My workflow for the majority of this project was to have Cursor and XCode running side-by-side, with Cursor directly modifying the project files so that the XCode preview automatically updates to let me try out the change in the simulator and course correct in Cursor if necessary</figcaption></figure><p>In Cursor, you can choose which AI model you want to use for your project. For the majority of the time, I had this set to “Auto” which worked relatively well for me. There were days when it ran into many issues like failing to directly apply edits to the files or not being able to create new files, at which point I had to switch to “claude-3.7-sonnet” (the latest Claude model from Anthropic). In the later phases of the project, I noticed that this model had issues with short context windows and constantly lost the plot on what I was trying to do, at which point I had to switch to “gemini-2.5-pro” (Google’s AI model which was free for a limited period of time) with which I had way more luck.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oI09NY_18DtZ60ccMkKAHw.gif" /><figcaption>Cursor allows you to switch between a variety of LLMs, all of which have minor nuances when it comes to what they’re good at and what they’re not. It’s not a bad idea to just leave it at “Auto” to start with</figcaption></figure><p>You don’t need to know the nuances between every single model, but I would recommend trying out the different ones to see which ones seem to get you the output you want. As the time of writing this post, <strong>Gemini 2.5 is the one I find to be the best because its inference and reasoning capabilities seem to exceed that of Claude</strong>. I only used the free models for my project, I didn’t pay for the Max models. Note that I did pay a $20/month subscription for Cursor Pro because I hit the limit for the maximum number of tokens on the free account (I think this is completely worth it given what you can achieve with the tool).</p><p>The hardest part about all this isn’t the setup or choosing a model in Cursor, it’s <strong>learning the various quirks of XCode to figure out where the different settings and options live that will let you preview your app correctly</strong>. It can be a bit confusing to figure out how to simulate a preview for specific conditions like when you don’t have the user’s location or when you need to test a specific failure condition. But you can always ask the AI agent in Cursor how to do this and it will tell you where to go and what option to enable to get it to do what you want.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ufq2Ajw-JTTwys1b2L7fww.png" /><figcaption>The XCode UI is incredibly confusing, from multiple nested navigation with unclear control elements to general bugs on views and windows that make it quite tedious for anyone unfamiliar with it to get going. Yes, it’s worse than After Effects, in my opinion. But thankfully, you don’t need to spend a lot of time in these clunky settings and project file views, you’ll mostly use XCode just for previewing your app on a simulator 90% of the time.</figcaption></figure><p><strong>If you haven’t used XCode before or are easily frustrated by unintuitive software, be ready for a bit of a learning curve here.</strong> You can easily find the answers by asking Cursor or some googling, but there were several tasks like adding custom fonts that I expected to be simple that turned out to be incredibly tedious and time-consuming due to how awkward the process is (which is surprising coming from Apple). <strong>The developer experience is just not great here</strong>. Be patient and give yourself time to learn and understand the tool as you get into it.</p><p>You don’t need much to get going. Start a new project in XCode, select <em>App</em> to tell XCode that you’re building a Swift app, and select the <em>ContentView.swift</em> file that it automatically creates in the project. Then go to Cursor, choose open folder, and select the project folder that you just created. Select the same <em>ContentView.swift</em> file to open it in Cursor too. Now you’ve got the basic workflow setup where any modification Cursor makes to the file (or anywhere in the project folder) will also reflect in XCode.</p><h3>Chapter II: The path to prototyping</h3><p>Now that I had everything setup, there was a blank text box with a blinking cursor staring at me, ready to start building whatever I wanted. I wasn’t going in completely blind here, I did have some initial seed of what I wanted to build here, but didn’t have a detailed idea of what that thing would be yet. <strong>I wanted to iterate and prototype my way to some MVP product based on what is and isn’t working and refining as I go</strong>. Given that I had absolutely no idea what the AI tool’s capabilities were at this point, this seemed like the most sensible approach instead of creating some design mocks in Figma and forcing myself to adhere to those constraints that the AI might struggle to execute.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*ivGa3kcapG5H4ldv9C0JpQ.gif" /><figcaption>Cursor’s blank canvas offers a tempting value proposition: <em>Plan, search, build anything</em>. Well, what did I want to build? I realized I hadn’t given this much thought in all my excitement about setting things up!</figcaption></figure><p>Also, I personally just needed to play and interact with how the thing is feeling to make a lot of design decisions on what to keep or change. <strong>When you’re dealing with complex interactions, it’s not always possible to make those design tradeoff decisions with static mocks in a Figma file.</strong> Interactive prototypes help, but you can probably tell that it would be incredibly tedious to set up a prototype for something like Poker Slam that randomizes cards and does validation checks on selected cards. I’d be making up mock scenarios — <strong>why do that when you can directly prototype it in code? </strong>So I jumped in, having no design mocks or product requirements guiding me because I didn’t entirely know what I was building yet. It was time to figure that out.</p><h4>The initial idea</h4><p>At the beginning of this year, I developed an unhealthy obsession with <a href="https://store.steampowered.com/app/2379780/Balatro/"><strong>Balatro</strong></a><strong>, an addictive card game</strong> where you make poker hands based on some modifiers that can drastically change the hands you’re making. It’s got roguelike mechanics that randomize runs and give you different conditions to meet in each run. Your goal is to exploit the modifiers at your disposal to achieve the highest possible score.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*o_WN0SCA2-g9MJcSd1JzSw.gif" /><figcaption>Playing a flush in Balatro gives you points for the flush in addition to several additional bonuses that you can strategically trigger based on what modifiers (Jokers) you have in play. Image source: <a href="https://store.steampowered.com/app/2379780/Balatro/">Balatro trailer</a></figcaption></figure><p><strong>What I loved about Balatro is its surface-level simplicity and deep complexity</strong>. A deck of playing cards is a universally understood concept. You don’t need to explain to anyone what an Ace of Spades or a Seven of Hearts is and how it works, they just get it. <strong>Building on top of a familiar mental model is a great way to make the game feel approachable.</strong> You start the game essentially making poker hands like pairs, flushes, and straights, a medium-complexity gameplay element that most people can latch on to quickly as they learn it.</p><p>Then it adds Jokers as modifiers like <em>Even Steven</em> which doubles your score for every even numbered card like 2, 4, 6, and so on played in your hand, or ones like <em>Fibonacci</em> which doubles your score for if your played hand includes numbers from the <em>Fibonacci</em> sequence like 2, 3, 5, or 8. The real strategy of the game is when the modifiers stack, like when you play a Flush involving a 2, 4, 8, 10, J all of the same suit. You get points for a flush, and the four even numbers double your score four times, and the two Fibonacci numbers double your score two more times. <strong>It starts off simple and gradually increases in complexity as you get depeer into it.</strong> The core gameplay loop is surprisingly addictive and it kept me hooked for a long time.<strong> I used this as a reference for how to keep the game feeling simple and approachable throughout my entire build.</strong></p><p>But I’m not just making a Balatro clone, am I? My idea was to mash it up with something else. I just so happened to also be playing <a href="https://store.steampowered.com/agecheck/app/2909400/">Final Fantasy VII Rebirth</a> around this time, a long RPG that contains dozens of mini-games within it, one of which is a strategy card game called <em>Queen’s Blood</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*T2Q8w9g__nluwQityGjekQ.gif" /><figcaption><a href="https://store.steampowered.com/agecheck/app/2909400/">Final Fantasy VII Rebirth</a>’s Queen’s Blood minigame that pits you against an AI opponent in a territorial control strategy card game; the goal is to win positions and outscore your opponent. GIF source: <a href="https://www.youtube.com/watch?v=K5z-ZRQD5-I">YouTube</a></figcaption></figure><p>Similar to Balatro, <strong>I was really drawn to the elegance and simplicity in this game.</strong> The game has a persistent 3x5 card grid and two opponents take turns placing cards in positions that they control, scoring points with the played cards and gaining more positions with the played cards. The game ends when all spots on the grid are full, and the player with the higher total score in the majority of rows wins the game. <strong>The game is simple to understand but difficult to master</strong>, with each game playing out in dramatically different ways (even if the same cards are used). I especially <strong>loved how every micro-decision mattered in the final outcome with where to place cards, which cards to pick, and deciding which positions to take.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GDfsvfLUEVmhkeHFIUKtyg.png" /><figcaption>Positions, ranks, score, and slot patterns are a lot to keep track of and make Queen’s Blood feel intimidating for a casual audience. The minigame exists inside of a tactical RPG for a reason. Image credit to <a href="https://www.gamesradar.com/final-fantasy-7-rebirth-card-carnival-puzzle-solutions/">GamesRadar</a>.</figcaption></figure><p>The only problem with <em>Queen’s Blood</em> was that it used many confusing metaphors: the cards themselves were named after characters from the game, each card had a score as well as a placement requirement for the position it could be played in (for example, a card with a placement requirement of 3 could only be played in slots that had been upgraded to that level by neighboring cards that were placed before). All these things made it <strong>difficult to immediately parse what to do and how to play the game for someone unfamiliar with the broader game and its mechanics.</strong></p><p><strong>My idea to simplify this was to mash up Poker and Queen’s Blood.</strong> What if instead of using B-tier Final Fantasy enemies as the cards, we just use a standard deck of playing cards? It’s simple and easy to grasp. Placing a card would allow you to place cards in adjacent spots based on the slots you gained, and the number of spots gained could tie in directly to the rank of the card (for example, a 3 of Diamonds gains you only one spot adjacent to it but a Queen of Clubs gets you every single spot in that row). <strong>I wanted there to be an element of strategic decision-making</strong>, and this felt good to me, so I made a quick static storyboard of what this might feel like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Eu5sgHfLr4n_YZkj8SKrdQ.png" /><figcaption>My quick storyboarding for how turns would play out with the Poker x Queen’s Blood concept. Each playing card would have some built-in power for how many positions around it the card would be able to “win”, allowing more cards to be placed there in future turns. Cards refill every turn to always give you 5 cards to choose from. The game ends when all slots are filled. The player with the higher total rank of all cards on the board would win.</figcaption></figure><p><strong>This storyboard was incredibly helpful as an exercise to understand how the game would fit into a phone’s rectangular frame.</strong> There isn’t a lot of room, and having a 3x5 card grid take up the dominant viewport would only leave enough space for one row of cards on yours and the opponent’s side. It’s tight but workable. I started thinking through all the mechanics and gameplay of how each turn would play out, what information I needed to convey to the player in each state, and how the visual feedback for each state change would be communicated.</p><p>The game seemed interesting but it still <strong>wasn’t quite hitting the level of immediate approachability that I was going for.</strong> I really wanted a “no tutorial” type game where somebody could start tinkering with the mechanics and quickly figure out what to do instead of needing to learn what positions and ranks are. Additionally, the <strong>mapping of card values to the positions they gain didn’t seem as simple as I thought they would be.</strong> I would have to assign arbitrary values to cards from 2 through 9 for how many positions they could gain and then make face cards more powerful. There was just<strong> a lot of mental math and translation happening which went against the “plug-and-play” nature I was going for</strong>. On top of all this, the interaction design for game mechanics like this that involved an <strong>AI opponent which needed its own difficulty settings and actions would be really complex to pull off</strong>, and given that this was my first app, I was hesitant to pursue it. So I scrapped the idea and kept ideating.</p><h4>Diverging and converging</h4><p>So I went back to the drawing board. Instead of trying to mash Poker with an unfamiliar and offbeat game like Queen’s Blood, <strong>what if I tried to mash it up with something familiar instead?</strong> Ideally a game that is also universally recognizable and everyone conceptually understands.</p><p>Tetris is the most popular video game in the world, so I started there. I toyed around with the idea of the cards falling down (just as Tetris shapes do) with your goal being stacking the cards as they hit the bottom to create poker hands with adjacent cards to clear out rows. The more I tinkered with this, the more I realized it’s too complex to execute well. Unlike Tetris shapes, <strong>it’s hard to read a card as it’s moving on-screen and you have to make a stressful decision of where to move it as it’s falling</strong>. On top of that, there’s no point in rotating playing cards (unless I introduced some wacky game mechanic involving cards flipped sideways that would cause even more strange layout confusion and issues with the clean Tetris grid). And you run into a lot of situations where there likely aren’t any valid hands to be played, so you end up with a gridlocked state of the game where random cards are just stacked next to each other, which isn’t very fun. This wasn’t working, so I moved on to other ideas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QEYukwYfi-8sgGyJ0XEUEA.png" /><figcaption>Various concepts for mashing up poker with familiar and universally understood game mechanics. I abandoned the Tetris idea due to the stressful decision making of figuring out where to move the card as it’s falling (not as easy as it is with shapes). The crossword idea seemed promising but clunky in the zoom interaction design with lots of trial-and-error involved. The Sudoku idea seemed to evolve the crossword concept in an elegant way, so I wanted to pursue that further.</figcaption></figure><p>Millions of people play the crossword in the Sunday newspaper, and this is also an instantly recognizable framework. Rows and columns with clues and dedicated slots for letters that can form words with adjacent letters. I could totally have a crossword version of Poker where the clues for down and across are poker hands. The player would have to go through a process of deductive reasoning, inference, and trial-and-error to arrive at the correct solution. This actually had potential, but the tricky part about this is that <strong>I couldn’t figure out a good way to get it to render on a small phone that still looked good and played seamlessly</strong>. The entire crossword grid would be tiny on-screen, making it difficult to see what you’re doing. That, or I’d have to introduce some kind of zoom interaction to look at specific parts of the grid in detail. I wanted to avoid complex interactions and just keep a simple set of cards on-screen at all times that didn’t change too much over the course of the game, so I chose not to pursue the crossword concept either.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*mgtLUxjZe2r645dHTwg96g.png" /><figcaption>Example of a sudoku poker puzzle used in the 2012 World Puzzle Championships (<a href="https://archive.nytimes.com/wordplay.blogs.nytimes.com/2013/03/11/wpc/">source</a>)</figcaption></figure><p>While I had a newspaper open, I caught glimpse of <em>Sudoku</em>, which I felt would actually be a really good fit for this mashup. There’s always a static grid on-screen with empty slots, and your goal is to fill it in. <strong>It’s super intuitive to figure out <em>what</em> to do but the complexity lies in <em>how</em> you do it.</strong> How do you ensure that each column, row, and diagonal has unique numbers from 1–9 while ensuring that they don’t conflict with the rest of the row and columns? It had the right balance of <strong>approachability and deep strategy</strong> that I was looking for, and I could already picture a grid of playing cards working well here (provided I had specified a condition to meet for each row and column). Maybe each row and column has unique poker hands like Flush and Straight that you’d need to create to satisfy its conditions, and those can play into the conditions for the other rows and columns?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VhFQtuFhK9Ld3JDzLbCBmQ.png" /><figcaption>Another example of how to build a valid puzzle like this that I used as a source of reference and inspiration as I l planned the end goal for how I would prompt the AI (<a href="https://time.com/archive/6643232/the-answer-men/">source</a>)</figcaption></figure><p>I also started thinking about potentially having multiple levels that increase in complexity and difficulty as you go on. For example:</p><ul><li><strong>Easy</strong>: 3x3 card grid where you make simple hands like pairs, three-of-a-kinds, and “mini straights” (a.k.a, a 3-card straight)</li><li><strong>Medium</strong>: 4x4 card grid where you make more advanced hands like two pairs, four-of-a-kinds, and “nearly flushes” (a.k.a, a 4-card flush)</li><li><strong>Hard</strong>: 5x5 card grid where you make complex hands like full straights, flushes, and full houses (a.k.a, traditional poker hands)</li></ul><p>I figured I could have ten of each difficulty levels, resulting in <strong>30 total levels that lets the game gradually increase in complexity</strong>. I’d have to create unique puzzles for all these variations with different dimensions of the card grid to ease the player into the way the game works.</p><p>While doing some research to see if anybody else had already built a game like this, and stumbled upon the fact that this exact idea was used in the <a href="https://archive.nytimes.com/wordplay.blogs.nytimes.com/2013/03/11/wpc/">2012 World Puzzle Championships</a> as a logic puzzle, and people had written about how to go about <a href="https://medium.com/the-grey-matter-party/lets-sudoku-the-poker-69d88ac573f">building this type of puzzle</a> at length, which I could use as a reference to guide the AI as we build the logic.</p><h4>Prototyping the idea</h4><p>Contrary to how someone else would start a prototype like this, <strong>I started with the frontend UI</strong>. You may think this is blasphemy and that I should have all the backend logic for how the hands work and are validated figured out first, but at the end of the day, I’m a designer first and <strong>need to see and play with the experience to get a sense of what it will feel like</strong>. If I don’t have this, I can’t make design decisions and tradeoffs to figure out what I should change or tweak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lmbTMPY-5hrjjcAMmTrWRw.png" /><figcaption>The idea involved expanding the gid size for increased difficulty. This necessitated introducing more poker hands that can be formed in sets of 3 and 4, which there aren’t a lot of in traditional poker hands. I allowed 3 and 4 hand variants of Flushes and Straights to solve this problem and labeled each row and column with the condition it needed to satisfy to solve the puzzle. Players would drag the relevant cards from the swipeable carousel of cards below to place them in card slots</figcaption></figure><p>One problem I immediately noticed into is that <strong>there’s simply too many possible cards to choose from a deck of 52</strong>, even to fill out a 5x5 grid of 25 cards. If one of the row requirements is <em>Flush</em> and the entire grid is empty, you’d have no idea what to try here because <strong>any suit and any rank of card is technically valid to play in any card slot in the row</strong>. I tried solving this problem by pre-filling some of the cards in the grid, so that if you see a Diamond card in a row whose condition is <em>Flush</em>, you know to fill it in with other Diamond cards. Even then, <strong>there’s simply too many possibilities</strong>, and the interaction design of choosing a card from the swipeable set of cards below, placing it, and removing it (if you didn’t want it) was turning out to be super complex, so I abandoned this path.</p><p>An alternative idea I had is <strong>instead of forcing the player to select cards from a deck, what if we already had the 25 “correct” cards pre-filled on the grid but shuffled around?</strong> That way, the player’s goal becomes swapping the cards to the right positions by switching the positions of the cards with the existing cards on the grid. <strong>The cards are all there, they just need to switch them around. This also greatly simplified the number of possibilities you had to validate and check, since the 25 cards that formed the solution are already on the grid, just in the wrong position.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MAmTe0cBXqdGZWqLi4j9OQ.png" /><figcaption>Iteratively building the UI with Cursor, where I started with the base grid and mock data, then creating some highlight validation UI when row or column conditions have been met and adding differentiation through colors for which cards are satisfying which condition (row or column). Not needing to have swipeable row of all cards in a deck to choose from and place in the grid greatly simplified the interaction design, since there’s just a static grid on-screen at all times now.</figcaption></figure><p><strong>To build this prototype, I started with the most complex difficulty, a 5x5 grid of cards</strong>, because I knew I could scale it down to the 4x4 and 3x3 grid easily if I nailed the interaction design in the 5x5 grid. <strong>I asked Cursor to create start by creating a 5x5 grid and fill in cards in the grid along with creating the UI for row and column conditions. </strong>I had the grid rendering with conditions for each row and column showing, along with unique colors to signify when a row or column condition had been met. I decided not to do diagonal conditions to keep it simple and not need to deal with figuring out how to show the diagonal condition in the UI with such limited screen space.</p><p><strong>The hardest part from here though, was creating the puzzles themselves</strong>. I had naively assumed that there would be a viable solution if we just assigned each row and column a poker hand. This is actually a really critical assumption, because <strong>the entire game doesn’t work if there isn’t at least one valid solution to each puzzle.</strong> Given that I had seen valid examples of puzzles in the research I did, I figured it would be easy to come up with the 30 puzzles I needed with different difficulty levels, but boy oh boy, did Cursor had other plans for me.</p><h4>The dreaded AI rabbit hole</h4><p>When I began to work on creating the puzzles, I did the most natural thing: <strong>I asked Cursor how to create the puzzles and give me a detailed implementation plan.</strong> It told me that there’s too many combinations of a 5x5 grid puzzle with poker hands in each row and column, so it wouldn’t be able to give me an answer right away. <strong>Cursor suggested writing a program to sift through all possible grid combinations and find valid puzzles where cards can be placed in the 5x5 card grid slots</strong> to satisfy all the row and column conditions, to which I naively said yes.</p><p>The next several hours involved many Cursor crashes due to the program exceeding the available memory of my machine. It suggested writing a terminal command line interface program in Python to speed things up, to which I also naively said “<em>Sure, why not?,</em>” let’s see how many puzzles we get. <strong>This program was a full-on combinatorial solver that used a brute force multi-armed bandit algorithm to work through every possible hand placement</strong> in every single row and column of the grid while simultaneously checking whether every possible card placement in each slot of the grid could satisfy the row and column conditions for the entire grid. If it found a solution, that would become a valid puzzle. I needed 10 of these, and that’s just for the 5x5 grids.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M9LdiSGM52ttyX8jVfWyOw.png" /><figcaption>Cursor wrote an insane multi-armed bandit brute force combinatorial solver to find valid solutions to the puzzles in Python. I had no idea this would get so complicated so quickly. Image created with GPT-4o</figcaption></figure><p>I could not believe how long this took. <strong>This program took 8–12 hours to run through all the possible combinations, and it kept presenting the “wrong” puzzles as valid solutions</strong> where it would often fill in duplicate cards in the grid, or put in cards that don’t actually form poker hands, or fail to correctly validate both the row and column conditions. I let this program run in the background while I was working on fine-tuning the UI and looking up more tutorials. I even left my machine running overnight multiple times just so the program could finish running, at which point I started questioning if I was in way over my head with this project.</p><p>After finally ensuring that the program was correctly checking all the requirements before presenting a solution, I was dismayed to learn that <strong>the only possible solutions to the puzzles were ones where we severely restricted the types of hands that needed to be formed</strong>. For example, <em>Pair</em> would need to show up multiple times in the grid if we have other hands like <em>Four-of-a-kind</em> and <em>Straight</em> because those higher-ranking hands use up a lot of the critical cards we need for other hands. <strong>If you use up the four 7s for a <em>Four-of-a-kind</em>, you cannot create any straights using 7s because they’re all used up for the <em>Four-of-a-kind</em> hand.</strong> So the only way to get valid solutions to the grid was to <strong>restrict the types of hands that could be played</strong> and only have a few hands involving four or five cards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q5qeXH7icHXMAE8CLozQ1g.png" /><figcaption>The only “puzzles” the algorithm came up with were just too simple and not fun at all to solve. There were multiple solutions with the same cards on the grid, which was interesting, but process of solving the puzzle was simply too easy. There wasn’t any strategy or reasoning required to fill in Pairs in every row and column.</figcaption></figure><p><strong>This resulted in a lot of puzzles that were just way too easy to solve. </strong>The puzzles usually had three “difficult” hands like <em>Straight </em>and<em> Full House, </em>so for a player, it naturally made sense to start with those. Once those were complete, the rest were mostly pairs, which made it way too easy to complete. <strong>There was no strategy or logical decision-making the way I originally wanted </strong>with the Sudoku theme, this just fell flat and wasn’t fun or interesting to play.</p><p>I was really surprised by this outcome, because there <em>are </em>valid puzzles that can be formed (as evident by those posts I found in my research), but there may be far fewer valid solutions to a game like this than I had originally anticipated. <strong>Even if I did find a better solution by loosening the rules of the game or relaxing some constraint, I’d maybe only have 1–2 puzzles at most.</strong> Then what exactly is the game — is it just a single puzzle? And the app just is over when you’re done solving it? That didn’t feel right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TUmf_Lbgk0Q0sJma3QDEkQ.png" /><figcaption>I started at various iterations of something more or less like this for…hours hoping that tweaking some variable would help the program find valid puzzles for me to make, all to no avail. This gave me too many horrid flashbacks of all the Operations Research and Statistics courses I took in college. Image created with GPT-4o</figcaption></figure><p><strong>I want to address that this is one of the pitfalls of relying entirely on AI to guide your process. You can ask it what to do, sure, but it will often take you down a deep rabbit hole that may not be the right one for what you want.</strong> This was a good example of that, as I absolutely did not expect to be waking up on multiple mornings anxiously waiting to see if the combinatorial solving algorithm I had left running overnight found any valid puzzles for me to implement into my prototype. You need to have the judgement and intuition to know when to pull back and change course in situations like this.</p><p><strong>I had to make a tough call here and decided to scrap this concept completely. </strong>It was totally worth prototyping to see if this can be done, and it was good to validate that there aren’t indeed any valid solutions that make a “fun” puzzle the way I originally intended. On top of that, I wasn’t loving the fact that I had to display tiny text labels on each row and column in the UI that broke the symmetrical grid and resulted in an inelegant game layout. There had to be a better way to do this.</p><p><strong>The low point of a personal project is when most people decide to give up on it. This was rock bottom where I realized my grand ambition for a 30-level puzzle game weren’t going to come to fruition given the complexities with generating puzzles. </strong>You’re undoubtedly going to hit this wall with whatever you’re doing as well. My only advice here is to keep going and push through it, because you might hit a breakthrough now that your understanding of the problem space is more complete than ever before.</p><h4>The final pivot</h4><p>I took a break for a few days to step away from this endeavor and decided to look at the most popular puzzle games on the App Store. Games like Candy Crush and Best Fiends seemed to hit that right note of being extremely simple and approachable, and all you had to was match similar shapes, which is kind of like creating flushes in a game of poker. My brain got rolling with this idea and I had a sudden flash of insight:<strong> instead of forcing conditions onto the grid like I was trying to with my prototype, what if we just populate random cards on the grid and let players create the poker hands themselves?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VlSEulZQvYXmr6ZhDcr8Yg.png" /><figcaption>This concept of just displaying random cards on the grid and allowing the player to choose poker hands themselves solved so many problems. It kept the UI clean without needing any text labels and removed the need to create different levels, re-using the same grid but just with randomized cards each time</figcaption></figure><p>This eliminates the need to have persistent labels entirely and allows for a clean 5x5 grid to be displayed on the UI at all times, making it simpler to keep track of the game state for a player. This also<strong> doesn’t require any puzzle validation to create and store puzzles in memory </strong>if I can figure out a way to always have valid playable poker hands in a random grid. Best of all, I can<strong> randomize the grid each time and have an infinitely replayable game</strong>. I started excitedly jotting down notes on what this would entail:</p><ol><li>To avoid a situation where there aren’t any valid poker hands on the grid of cards, I would need to <strong>allow for more “valid” poker hands to be formed </strong>even if they aren’t really poker hands, similar to how I did in my prototype. The goal is to always have some hand available for the player to form and play (until we run out of cards)</li><li>I would need to <strong>allow more flexibility in how hands are formed</strong>, perhaps the ability to connect cards diagonally and allow any order in the sequence. For example, choosing the <em>5</em> card in the middle of the grid first should then allow you to choose a <em>6</em> to the left to it and a <em>7</em> diagonally to the the top-right of it to form a 3-card straight. Any clustering of cards should have a valid hand in it, in any order as long as they are all directly adjacent to each other</li><li>Once valid poker hands are played, those <strong>cards need to clear out from the view and new cards need to populate in</strong>. I felt like a Candy Crush like mechanic here would work well where the rest of the cards in the grid shift down and new ones appear at the top. This also adds an element of strategy where you can plan for the cards in the grid to shift downward and create the potential for new hands with the existing cards in the grid, giving players who plan ahead a key advantage</li><li>When the player selects a set of cards, I needed to <strong>show a predictive display of what the hand they’re playing is and how much they’re going to score with it</strong>, allowing them to add further cards or change the set of cards to try and maximize the amount they can score before confirming</li><li>If we always have some valid hand to play, the <strong>goal of the game now becomes figuring out <em>which</em> hand to play next</strong>. I needed to create a scoring mechanism and assign a score to each possible playable hand, with the rarer hands being worth more</li><li>For the players unfamiliar with poker hands (and especially because we’re adding net new hands that even those who know poker wouldn’t know), I needed to have some kind of <strong>view where players can reference what all the possible playable hands are and what they’re worth</strong> so they can plan and optimize a strategy around the high-scoring hands</li><li>This <strong>card grid needed to refresh and randomize in every new instance</strong>, allowing a fresh set of cards to play each time the game is restarted. I needed to track the player’s highest score across all the game instances and display a “New high score” callout if the current game’s score exceeds their past highest score</li></ol><p>There were a few more interaction design details and gesture behavior to figure out on how the player actually selects cards, but I could get to that later. <strong>I wanted to first see if these new sets of guiding principles could get me to a playable MVP of the game with actual working mechanics.</strong> I’ll also point out that I didn’t have any PRD or technical requirements doc in this phase of the project. This was just me experimenting and ideating to see what I’d even like to build.</p><h3>Chapter III: Building the game</h3><p>Since I was starting fresh with a new idea, I wanted to really lay out all the requirements of what I was trying to do in one single initial prompt. Given all the issues I had with Cursor in the dreaded prototype build, I decided to go outside of Cursor and use ChatGPT for this, which seemed to be better for high-level project planning, especially with the new 4o model. Here is the exact prompt I gave ChatGPT 4o along with an explicit ask at the end for how to actually prompt Cursor to build it:</p><blockquote>I want to create a candy crush like app written in Swift where your goal is to find and create poker hands from a grid of playing cards. The rules of the game are as follows:</blockquote><blockquote>1. When the player starts the app, a main menu should appear with three options: Start, How to play, and Settings.</blockquote><blockquote>2. Tapping Start should start the game. The game starts with a 5x5 grid of 25 randomized playing cards from a possible set of 52. The player’s goal is to try and find pairs, flushes, and straights in the grid. The player should also be able to create two pairs, three of a kinds, and four of a kinds. For straights and flushes, they should also be able to create them in hands of 3 and 4 cards (not just 5). The 3-straight should be called “Mini straight” and the 4-straight should be called “Nearly straight”. The 3-flush should be called “Mini flush” and the 4-flush should be called “Nearly flush”. In total, the playable hands in this game are: Pair, Two Pair, Three of a kind, Four of a kind, Full House, Mini flush, Nearly flush, Flush, Mini straight, Nearly straight, Straight.</blockquote><blockquote>3. While the game is running, the player’s score should be displayed at the top of the screen.</blockquote><blockquote>4. To select a hand, the player swipes across a row, column, or diagonal of the grid to find and select poker hands. As the player drags across a set of cards (minimum 2, maximum 5) in a row, column, or diagonal, the cards should go into a selected state. If the selected cards form a valid poker hand, the name of the poker hand should display above the grid along with the score that it is worth (for example, “Flush +80”). If the selected cards don’t form a valid poker hand, nothing should display in the spot above the grid. To submit a selection of cards, the player taps on any of the selected cards again to submit the card selection. When submitted, those cards disappear from the grid and the score for the poker hand is added to the player’s score. If the selected cards don’t form a poker hand, the cards just do an error wiggle and revert back to their regular unselected state.</blockquote><blockquote>5. The player’s score is calculated based on the rarity of the poker hand they’ve played. The score should be a points-based system where the highest ranking possible playable hand has a score of 100 and the lowest has a score of 5. The 5-card set of hands should score higher than the 4-cards set of hands, and the 4-cards set of hands should score higher than the 3-card set of hands.</blockquote><blockquote>6. When the cards for a played poker hand disappear from the grid, the rest of the cards that are positioned directly above the cards that were played should fall into the positions directly below them. The grid should always stack cards at the bottom, leaving empty spots on the top for new cards to appear into.</blockquote><blockquote>7. New cards that fill into the empty spots at the top of the grid should be randomly drawn from the remaining set of 27 cards that were not originally on the grid. The player can now continue forming poker hands on the grid. The grid should always be full until we run out of cards to draw from.</blockquote><blockquote>8. The game ends when the cards either run out or the player is no longer able to create any valid poker hands from the available cards on the grid. A “Game over” message displays below the grid with a button to start a new game, which would start a new game with a new randomized grid of 25 cards for a new game session.</blockquote><blockquote>9. The game should keep track of the player’s score across every game session where they reached the end of each game. The player’s score at the end of each game should be displayed below the “Game over” button. If the player’s score at the end of a game is the highest they have ever scored, a “New high score” message should display below their score. If the player’s score at the end of a game is not the highest they have ever scored, the high score should display below their score for the game. The high score should have a “High score” label.</blockquote><blockquote>Give me a detailed implementation plan of how to prompt Cursor to setup the basic project architecture for an app like this. I want to have all the core functionality setup correctly so that all the game logic is working as intended.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y3NRY_dyQE3LSoDx9W478w.png" /><figcaption>ChatGPT’s suggestion for how to setup the project structure and files in the XCode project</figcaption></figure><p>I felt like this prompt would be enough to get the basic project architecture setup with the correct logic and gameplay hooked up. I wasn’t worrying about UI details and interactions just yet, all those can be fine tuned after the core functionality is implemented. <strong>You want to be careful not to overwhelm the model with too much information about your game, or else you risk confusing it and not getting what you want out of it.</strong></p><p>As requested, ChatGPT outputted a bunch of sample prompts I could give to Cursor to setup the basic project architecture. I gave me one huge code block to start with, which I directly copy+pasted into Cursor to start off. ChatGPT had several more follow-up prompts that I was to copy+paste as well, but the initial prompt resulted in <strong>over 40+ XCode build errors that I had to diligently go through and resolve</strong>, at which point Cursor had lost context of the original step it took, so I sort of cherrypicked the most important bits from the follow-up steps and kept giving it to Cursor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uv9QrdYrc0IqJdAlGFaFFg.png" /><figcaption>While not perfect, this served as a great starting template where ChatGPT had recommended the best way to prompt Cursor with setting up the different files and models needed to pull off this game</figcaption></figure><p>After fixing the build errors, <strong>Cursor had all the necessary project files with dependencies and created a base style for playing cards with a 5x5 card grid to populate in the view</strong>. I went through the code and the game myself to check if it was all setup in a way where I could easily modify the layout and styling of elements myself later as long as the core features were ready and served up a few follow-up prompts to fix some issues I noticed in the game itself. One big glaring error was that drag gestures weren’t really implemented the way I requested, and it was just setup to take individual card tap actions. I figured this was fine for now and that <strong>I could build the MVP using tap actions to validate functionality, after which I could convert it to swipe/drag gestures</strong> to enhance the card selection experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FBf1QsjdxRzxksbYgrUbyw.png" /><figcaption>My designer eye wanted to keep working on the UI &amp; styling before I even had the game working, so I took every little opportunity while Cursor was thinking to keep refining the UI and develop the visual language for the cards and started experimenting with gradient effects for the overall background.</figcaption></figure><p>I tweaked some UI &amp; styling of the cards to only have a rank and suit displayed for clearer legibility and scanning and <strong>updated the UI to have some color differentiation amongst the suits</strong>. I also setup Git at this point and started regularly committing my code to a Github repo so that I could retrieve older builds in case something went catastrophically wrong (which it did, multiple times). The next step was to actually create the game, where a player selects a set of cards and tries to form poker hands.</p><h4>Fixing errors with Cursor</h4><p>Most of my time around here was spent debugging errors that XCode was throwing at me. The best way I found to resolve these is to <strong>copy the errors and paste them directly into Cursor, at which point it will go through and make targeted edits to fix those files with specific errors.</strong> Be prepared to do this a lot, since the AI models don’t have all the knowledge of specific nuances when it comes to how XCode wants you to setup your project or what Apple’s Swift best practices expectations are.</p><h4>Poker hand validation</h4><p>I had to build the logic to check and validate poker hands as the player was forming them. This was the meat &amp; potatoes of the core game logic. Cursor did an <em>okay</em> job at taking a first pass at this, but it had a long way to go. It was only checking for a few core poker hands (not all that I wanted), it was only displaying validation for the first created hand (not the higher-ranking hand if you selected more cards), and was too rigid with its adjacency checks where it only allowed hands to be formed in a certain direction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wdvVIbxlBC50aO9KIav1ow.png" /><figcaption>The ChatGPT prompt instructed Cursor to set up the basic bones of the poker hand validation file, but I had to do a LOT of tweaking here to get it to work the way I needed it to</figcaption></figure><p>I re-prompted Cursor with a list of every single hand, including the 3 and 4 card hands that I wanted to allow so that there’s a lot of options to choose from in a randomized grid. I actually had to think a lot about this — <strong>the hands couldn’t be too easy and that it’s mindless and couldn’t be so difficult that you run out of hands too quickly</strong>.<strong> I came up with around 15 hands that would be intuitive, easy to remember, and quick to identify. </strong>I tested this thoroughly over many randomized card grids and there seemed to be enough variations to make until the deck of cards was nearly over, which was really satisfying.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V6lmO7d80iCigtuhlAqE6g.png" /><figcaption>I manually added in titles and scores for every possible hand I wanted to be playable in the game as a valid hand. Examples of 3-card hands and 4-card hands (that aren’t traditional poker hands) shown here</figcaption></figure><p>I decided to embark on quite the misadventure by attempting to add two Jokers (as you normally find in a deck of cards) that would show up, which <strong>completely broke the poker hand validation because a selection of 5 of Clubs, 6 of Clubs, and a Joker could validate either as a <em>Mini Straight </em>or a <em>Mini Flush, </em>and the app kept crashing when a Joker was selected.</strong> I didn’t expect this to be so game breaking, and attempted various fixes over the course of several hours because I really liked the random variety Jokers added. I’ll spare you the details, but Cursor’s AI models started hallucinating at this point and I had to revert back to an older build. I gave up on the Jokers for now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L6jn-Q58x47H9lL6F1E6GA.png" /><figcaption>As I kept adding features, I was creating placeholder designs on-the-fly, adding states and UI elements as needed to get the core functionality working before revisiting and refining all the design later</figcaption></figure><p>Another painful prompt engineering exercise was getting Cursor to allow building straights through Aces. So for example, K-Q-A-2–3 would be a valid playable straight. It did this, but then broke the functionality for Aces to be validated as a high card or a low card in a straight, which meant you couldn’t create 10-J-Q-K-A or A-2–3–4–5 as straights. I had to really go back-and-forth with Cursor a lot here and be extremely explicit about the fact that <strong>Aces could be a high card, a low card, or just a bridge between the high and low cards in a straight.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U_TBfPfVHPCm5dqs1ku4qw.png" /><figcaption>To increase the number of options for playable hands, I really wanted players to be able to create straights through the Ace by looping from high to low ranks, but this proved to be extremely complex for Cursor to implement. It eventually figured out how to validate it by rigorously checking the hand on every card selection.</figcaption></figure><p>To implement this, Cursor’s AI models had to essentially continually validate whether a selected Ace in a hand was currently being used as a high card or a low card. If the other selected cards in the set were a K or below, it would keep the Ace as a high card. If the other selected cards in the set were a 2 or higher, it would keep the Ace as a low card. If the other selected cards in the set were both a K and a 2, it would keep the Ace as a “bridge” card to allow for creating the straight. This Ace-bridge validation logic was specifically implemented when checking for straights with an Ace in it.</p><h4>Taming Cursor with rules</h4><p>At this point, I noticed a recurring problem. <strong>Cursor was constantly doing random things to the codebase where it was overwriting its own code in a different way, deleting entire chunks of code just to fix a small issue, and removing old features without asking me</strong>. This was incredibly annoying, because you couldn’t build on top of systems as Cursor was dismantling them with every new prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0UYCnmz6mkLX1p5LLirAbA.png" /><figcaption>Example section of what my rules.mdc file looked like (<a href="https://github.com/akhil-17/PokerSlam-3/blob/main/.cursor/rules/rules.mdc">full file here</a>)</figcaption></figure><p>A simple solution to this was to have a <em>rules.mdc</em> file with explicit instructions that you told Cursor to reference every single time, before executing the command for every single prompt. <a href="https://github.com/akhil-17/PokerSlam-3/blob/main/.cursor/rules/rules.mdc">Here is what my <em>rules.mdc file </em>looked like</a>, which I made from a hybrid of several sources I found on the internet. Feel free to copy it for your Swift project as well. Cursor’s site has some <a href="https://docs.cursor.com/context/rules">good documentation</a> on where to put it in the project. <strong>This single file saved me hours of headaches because Cursor would always check against it and make sure that it’s not breaking existing functionality and deleting old code while implementing new features</strong>. It also completely stopped Cursor from adding random things I didn’t ask for, which I greatly appreciated. <strong>Overall, this was the single biggest net improvement I made to my workflow in this project.</strong></p><h4>Selecting cards and playing hands</h4><p>In the original prompt, I asked Cursor to implement the “submission” of a playable hand by tapping the set of cards again. This actually ended up feeling quite confusing, as it didn’t feel like a submit state and I realized that tapping the set of cards to “unselect” a card (basically reverting the select action) felt more natural. So I separated the submission action from the select action and created a separate “Play hand” button at the bottom of the grid to submit the selected hand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v2mdjYD_KYzP9GoRi_I4-A.png" /><figcaption>Tapping a card would select it, for which I added a quick visual border. Tapping nearby cards would also select them, and when a valid hand is formed, the name of the hand with a preview of your score would display above the grid of cards. I also de-emphasized the remaining cards that are “ineligible” for selection</figcaption></figure><p>Now, tapping a card again unselected it, which caused another slew of bugs and issues.<strong> You could now select three adjacent cards and then unselect the middle one, leaving you with two selected cards that aren’t adjacent to each other, breaking the adjacency rule.</strong> Worse, if those two remaining selected cards form a poker hand (like a pair), it would validate as a playable hand. So I embarked on another bug bashing adventure and came to a solution where you can’t actually unselect individual cards. <strong>Tapping on any card in a set of selected cards would unselect the entire set of cards, avoiding many bugs and potential problems.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zmfm1fnpW9oFgsux9Ecv3A.png" /><figcaption>Adjacent cards could be selected horizontally, vertically, or even diagonally. I wanted a selected set of hands to show a preview of the score (if a valid hand is formed) and not show anything if a valid hand isn’t formed. The idea is to allow the player to keep selecting and unselecting cards in the set until they’ve got a hand with the highest possible score with adjacent cards</figcaption></figure><p>With this new layout, one I thing my designer’s eye noticed is that related elements are in different parts of the layout. <strong>You’re viewing the grid to select cards, then seeing the name of the hand it forms above the grid, then tapping a new “Play hand” button at the bottom of the grid.</strong> I didn’t love this, but also didn’t know how to more elegantly solve it without merging some of the things together in the UI, possibly causing another cascade of bugs and issues due to the interdependencies they create with each other. So I accepted this layout for now and decided to revisit it later.</p><h4>Drawing connecting lines</h4><p>I had the game working with being able to select cards and form poker hands, but I wasn’t loving the fact that there wasn’t any good visual feedback about the fact that the cards had to be adjacent to each other. To solve this, I wanted to visually link cards with connecting lines and make it clear to the player that only adjacent cards could be linked together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DoPjaOv5LKggm-q80Q9CnQ.png" /><figcaption>When selecting a set of cards, I wanted connecting lines to draw between them to visually reinforce adjacency. It worked sometimes, but when cards were directly next to each other, it was drawing multiple lines adding lots of visual noise and making it confusing to read. I had Cursor write multiple test cases for these scenarios and I rigorously playtested it over and over again to ensure that only one connecting line was drawn between adjacent cards.</figcaption></figure><p>My initial few prompts worked seamlessly, and Cursor’s models seemed to understand what I was going for here. However, when selecting cards in a random order, the lines would sometimes draw multiple times from the same card or criss-cross over each other when connecting cards diagonally. To solve this, I asked Cursor to figure out a way to only draw a single connecting line from each card and make sure that they don’t overlap. <strong>I also needed the lines to continually update and redraw every time a new card is added to the set to adhere to this rule. Cursor implemented </strong><a href="https://en.wikipedia.org/wiki/Kruskal%27s_algorithm"><strong>Krusal’s Minimum Spanning Tree algorithm</strong></a><strong> to achieve this, and it worked immediately</strong>. No bugs, all behaving as expected. I thoroughly tested this and was very impressed. Sometimes, the models hit a home run, and they definitely did here.</p><h4>Filling in new cards</h4><p>I was now able to select cards, see the visual links between selected cards, view the hands they formed, and submit the select cards to score with the “Play hand” button. Cards were clearing out, but <strong>new cards were appearing in random spots, leaving gaps on the grid.</strong> I was pretty clear in the original prompt that I wanted the entire card grid to first shift downwards to fill the empty spots created by played hands before filling in new cards, but it seemed very buggy. I had to keep re-prompting the AI models multiple times to get this behavior correct.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SVM8F4Ig5URmalMmZevI6Q.png" /><figcaption>Getting the cards in the grid to consistently fall down after a submitted hands clears out of the grid proved to be quite the challenge. This also required multiple rounds of testing, debugging, and asking Cursor to write lots of unit tests to ensure that there are never any empty gaps in the card grid</figcaption></figure><p>Even after fixing this, there was another issue where<strong> if we ran out of cards in the deck, they wouldn’t fill in the correct spots.</strong> For example, if we played a <em>Straight</em> and five new cards needed to be filled into the grid but there’s only three cards remaining in the deck, they wouldn’t fill into the correct spots at the top of the grid. I had to implement very specific functionality to handle this state to ensure that regardless of how many cards are remaining or filling in, the grid would first shift downwards and then new cards would fill in the empty spots on top.</p><p>I also attempted implementing several custom animations here where cards animate downwards and new cards shuffle into the grid, but they caused <strong>so many race conditions and game-breaking bugs in where cards filled in that I decided to scrap it</strong>. It was causing more build issues and headaches that I really didn’t want to deal with.</p><h4>Getting Cursor to behave</h4><p>Another massive pain point I noticed around this point was that <strong>when I would ask Cursor to implement something as complex as animations, it would start immediately modifying several files with state managers and identifiers to call other files to tweak timing</strong>. It was <strong>difficult to keep track of exactly what Cursor was doing if you weren’t hyper-vigilantly observing the running code</strong>. And often, it wasn’t possible to undo specific things in the giant list of stuff it had completed in one go. So I switched things up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mV6_Xh97wiL8aH1rh3Y3Mw.png" /><figcaption>The second best thing I started doing in Cursor after the rules.mdc file was to ask it to always give me a detailed plan of <em>what it plans to do before it does it, avoiding several mishaps with implementing the “wrong” thing in the process by catching incorrect intent early on. Also saved me a ton of tokens</em></figcaption></figure><p><strong>Going forward, every complex prompt I gave Cursor began with me asking it to give me a detailed implementation plan, with numbered steps, of what it plans to implement, how it plans to implement it, and what files it plans to touch. </strong>This forced Cursor to analyze and print out what it would do <em>before </em>it did it, allowing me to quickly see, in plain English, what crazy adventure it was going to embark on. <strong>This was super insightful for me to understand how Cursor interpreted my prompt.</strong> Often, it got some things wrong which I was able to clarify and correct.</p><p>As an example of this working right: when I asked Cursor to animate cards falling down, it showed me an implementation plan that shifted the position of <em>all </em>cards in the grid, which is not what I wanted. I only wanted to shift the position of cards that had empty spots below them and all cards above them by one position down. I kept correcting Cursor’s implementation plans for every major feature and it helped immensenly in ensuring that there weren’t any unexpected issues with the actual feature implementation. <strong>This was another massive savior in ensuring that we’re not creating more issues and bugs as we go.</strong></p><h4>Game over state</h4><p>After lots of playtesting and bug fixing, the game was finally behaving as expected. <strong>Cards were clearing out for valid poker hands, cards shifted downwards in the grid to fill empty spots, new cards were filling in until the deck ran out, and the score was updating as expected</strong>. The last major feature I needed to add was a “Game over” state when we either ran out of cards in the deck or there weren’t any more valid playable poker hands in the card grid with the remaining cards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7qijHbKvUNnxRZZMX51DJw.png" /><figcaption>The “game over” state needed to end the game when all cards from the 52-card deck had ran out and there were no more possible poker hands left on the grid to create. This required implementing a continual check in the background of what all the valid “selectable” poker hands on the grid were, at all times.</figcaption></figure><p>To implement this, the code had to <strong>continually detect whether there are valid playable hands or not on the grid</strong>, something that it wasn’t doing before (it was only checking when cards were selected). Cursor implemented this check and the game now informed the player when there aren’t any more valid poker hands that could be played, triggering the “Game over” state. This also had several bugs and issues where I ran into states that theoretically should have been a “Game over” state but it wasn’t being triggered due to how the adjacency checks kept breaking when there aren’t any cards in certain columns (which is common in the endgame), so it also <strong>required a ton of bug-fixing </strong>until it worked right.</p><p>I also re-used the poker hand display text area to show a helpful message explaining why the game had ended, along with a “Play again” button that reset the game to a new instance. I also re-used this text area to introduce the game’s rules to the player at the start of the game with a message explaining what to do and how to play the game which disappeared as soon as the player interacted with at least one card.</p><h4>Viewing playable hands</h4><p>There was one last piece of the puzzle — <strong>I needed the player to quickly and easily reference what the playable poker hands in the game were</strong>. I had added some custom new hands that most players wouldn’t know, and <strong>I wanted a way for players unfamiliar with poker to quickly get a gist of the playable hands along with their score.</strong> So I asked Cursor to create an overlay view, accessible at any point during a game, that had a list of all the playable poker hands along with their respective score. I added example poker hands in the reference view as well, allowing players to preview the cards they would need to connect in order to form that hand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZHvfF57nX_V-Zj4tmJqtBw.png" /><figcaption>The V1 of the “Hand reference view” accessed by tapping the question mark icon on the top-right. The goal of this view was to provide players with a visual reference for all the playable hands along with their score. I had a basic version working for now and planned to refine the UI more later.</figcaption></figure><p>I organized this list in ascending order of score, allowing players to see the simplest and most common playable hands first, increasing in hand size and card rarity as we went down. It started with a <strong>Pair for a score of 5 points and went all the way to Royal Flush for a score of 100 points.</strong> Once the player had familiarized themselves with the possible hands, the game became more strategic the more they play as they try to score higher-ranking hands instead of just choosing simple pairs and flushes.</p><h4>Main menu</h4><p>After creating the view for referencing playable hands, <strong>I realized I actually didn’t need a separate “How to play” screen</strong>, especially because the game now had an introductory message of how to play. I also didn’t have any settings in this version of the game that the player could tweak or change (aside from a future idea where they could switch the theme of the playing cards), so I didn’t need that either. I asked Cursor to remove both the “How to play” and “Settings” screens and integrate the main menu directly into the view where the game starts with a tap action.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r8eWovlZj_Rx8QftqZvEXg.png" /><figcaption>A dead simple main menu was all I needed to have an introductory brand moment before jumping into the game. I removed the “How to play” and “Settings” screens entirely to keep it simple for the first version.</figcaption></figure><p>I still felt it was nice to have an intro screen in the main menu that you needed to interact with before getting into the game <strong>to avoid overwhelming players with a giant grid of cards as soon as they had opened the app</strong>. This sequenced the views nicely and allowed for a cool entry animation of the card grid down the line that now had a higher chance of being seen by the player because the player would have interacted with the main menu screen just before to get to the game.</p><h4>Score tracking</h4><p>The initial prompt for keeping track of a player’s score worked relatively well, save for a few bugs. It was correctly updating from “Score” to “New high score” every time the player surpassed their previous best, and tracking it across sessions. I toyed around with the idea of creating a leaderboard of some kind or just a local instance of your own top 5 high scores, but it felt like a bit overkill when I could just message the “New high score” number when you did better than your previous best.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jF-ySZvXrare5MJlYosboA.png" /><figcaption>Displaying high scores in the UI was as simple as replacing the “Score” label with “New high score!”</figcaption></figure><p>I also debated whether just displaying your high score in the main menu or elsewhere would be a worthwhile addition, because <strong>the game doesn’t actually show you your high score anywhere aside from just informing you that you’ve surpassed it</strong>. I wasn’t sure how much to prioritize this, so I skipped it for now (more on this at the end of this case study). All my testing so far was very focused on how the game works the first time you play it and replay it, not necessarily how you’ll want to continually beat your personal best, so I left it out of the MVP.</p><h4>Feature complete 🎉</h4><p><strong>Now that the entire game was working end-to-end, I breathed a huge sigh of relief.</strong> You could now open the game, tap the main menu, play the actual game, reference playable hands in a different view, and restart a new game when you had finished. The game was keeping track of your score and high score and informing you of the score for the hand that the selected card set formed before you submitted it. Everything was working as intended. Now came the actual fun part of why I even wanted to embark on this journey, which was to try out cool UI effects &amp; animations in Swift.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SAWW9sB7agnhVGB-0KbOEg.png" /><figcaption>Getting the core gameplay loop working end-to-end was a major milestone for me. It meant that the core logic of the game was set and I could now spend the rest of the time doing what I was most interested in doing, which is to play around with text &amp; UI effects in Swift to make something truly delightful.</figcaption></figure><p>I cringed internally when I called my build “feature complete,” because at my day job, I repeatedly tell my engineering partners that features aren’t “complete” until the UI is all behaving as expected and matches the desired look in Figma. But my god, it was such a slog to get to this point and put up with all of Cursor’s schizophrenic mania to rewrite entire features when asking for a simple change that<strong> it felt like a massive achievement to have a thing that worked end-to-end the way you wanted it to</strong>. Also in my defense, I didn’t have a Figma file I was referencing when building this prototype. I was winging it all, so I could technically call it “feature complete.”</p><p>I also want to take a moment to address that <strong>this is the point where most first-time vibe coders will call their project “done,” ship it, and move on</strong>. It is indeed a big deal to get to this point, and I totally understand the exhaustion that comes with it. But I wasn’t done. I was just getting started. I wanted to really go deep in animations and effects and spend a fair amount of time trying to get it to look the way I wanted to. This is what I felt would also really separate my app from the rest of the janky-looking poker games on the App Store whose UI looked like it was made by a casino that had $80 to spend on the design of their digital app.</p><p>Check out <a href="https://medium.com/@a_kill_/pt-2-2-vibe-coding-my-way-to-the-app-store-1ff57588ab41"><strong><em>Part 2</em></strong> of this series</a> to continue reading:</p><ul><li>Chapter IV: Refining the UI</li><li>Chapter V: Releasing to the App Store</li><li>Chapter VI: Lessons learned</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=539d90accc45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tips for designing internal tools]]></title>
            <link>https://medium.com/@a_kill_/tips-for-designing-internal-tools-c0500fcb9277?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0500fcb9277</guid>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[interface-design]]></category>
            <category><![CDATA[internal-tools]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Fri, 16 Dec 2022 01:09:14 GMT</pubDate>
            <atom:updated>2022-12-16T01:09:14.079Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ru20Om4ecVdZW1hYtVfqwg.png" /></figure><p>In my career as a designer, I’ve had the good fortune of working on a variety of things, from mobile consumer apps to enterprise web products to internal tools. I’ve written about the former two at length in previous case studies, so I want to focus on internal tools this time around. A lot of designers don’t consider them as interesting to work on as consumer-facing software, but there’s a lot of unique design lessons you can learn from working on them, and I figured I’d share what I’ve learned.</p><p>Internal tools have much lower visibility than customer-facing products, so they tend to be treated as second-class citizens at the organizational level. Many companies don’t even bother staffing the teams that operate and maintain internal tools with dedicated designers, with the misguided justification that only consumer-facing products “need” design and internal tools don’t. This becomes problematic because as the company scales, because not having a design foundation for tooling risks letting the tools grow into an unusable mess of cluttered features and confusing UX, which in turn makes it more difficult for the employees to serve their customer needs.</p><p>Most internal tools tend to be heavily task-oriented, geared around efficiency and performance optimization. As a result, designers working on these tools need very specific skillsets to succeed on these projects. They need to understand web apps, responsive layouts, service design principles, performance management, operational processes, and possess a whole lot of systems thinking skills. On top of all this, they need to continually strive to keep the view simple and usable as more and more features get crammed into the screen. I’ve certainly had an extremely rewarding experience working on internal tools, and I hope to show how they can be so gratifying to design for through this post.</p><h4>Context</h4><p>In my time at Lyft, I started out working on our internal support tooling. Thankfully, the company greatly prioritized the design of our internal tools, and almost every tool at Lyft had a dedicated team of designers, researchers, and engineers staffed to maintain and improve them for our users. I focused on support tooling, which is the surface that all of Lyft’s support and safety agents use to resolve issues (primarily via chat) for Lyft riders and drivers. It was a very complex view built on a custom instance of Twilio Flex, and I interfaced directly with our engineers as well as the Twilio team to ship many projects that made resolving issues in the view more efficient.</p><p>I’ll be using Lyft’s Twilio Flex instance as an example throughout these tips to illustrate the principle. The goal is to provide a good starting point for anyone looking to learn more about designing internal tools, so hopefully you find them insightful.</p><h3>1. Understand the business context of the tool</h3><p>Internal tools naturally have very different goals and usage metrics than their consumer counterparts. You’re not meant to design for growth and engagement but instead meant to design for efficiency and speed. Many designers, especially those coming from designing consumer products in the past, tend to fall into the trap of over-designing a beautiful, elegant UI where the most commonly-used features are buried in menus with the misplaced assumption that a “cleaner” interface will be more usable. In reality, it just takes longer for users to get through workflows.</p><figure><img alt="Lyft support agents utilize a custom instance of Twilio Flex in their web browser to resolve customer issues via chat, where a chat with customers is displayed on the left and an investigation view is on the right side." src="https://cdn-images-1.medium.com/max/1024/1*5BGdbcuYNOFV7bP_spTPAg.png" /><figcaption>Lyft support agents utilize a custom instance of Twilio Flex in their web browser to resolve customer issues via chat, where the conversation with customers is displayed on the left and an investigation/resolution view is on the right side of the screen.</figcaption></figure><p>In Lyft’s support tools, agents are measured on resolve time for each issue. The speed with with which they can click around and achieve common tasks is always top-of-mind when designing new features in Lyft’s instance of Flex. As a result, the key design metric is to minimize the amount of time it takes to get through the most common workflows in Flex. We measure the percent change in resolve time with every new feature we ship to ensure that it isn’t negatively impacting how fast agents can resolve issues. Understanding the business context that the tool exists in is critical to designing for the right end goals and measuring them effectively.</p><h3>2. Strive for a standardized, globally usable design</h3><p>Many global corporations deploy their tools all over the world. The hot new mobile design trend loved by affluent urban American consumers is not applicable to a tech support worker in India trying to make a living by utilizing the company’s internal tool to perform tasks day in and day out. The best approach here is to design internal tools to be culture-agnostic and utilitarian as much as possible. Since there’s a set of human beings depending on these tools for their livelihoods, these tools need prioritize reliability and consistency over delight and novelty as much as possible.</p><figure><img alt="One of my early exploration sketches for “floating” chats in Lyft’s instance of Flex, inspired by the globally-used Facebook Messenger on desktop. The idea was ultimately scrapped because it broke the visual chat-case link, causing confusion about which cases related to which chats." src="https://cdn-images-1.medium.com/max/1024/1*GtIw1WXYMeWO0cDcVJ1Z9Q.png" /><figcaption>One of my early exploration sketches for “floating” chats in Lyft’s instance of Flex, inspired by the globally-used Facebook Messenger on desktop. The idea was ultimately scrapped because it broke the visual chat-case link, causing confusion about which cases related to which chats.</figcaption></figure><p>Lyft’s support tooling is utilized by over 1500+ agents in partner sites all over the world, from countries in South America all the way to Europe and Asia. When designing for these tools, it’s essential to be aware of cultural nuances when it comes to usage of colors, interaction patterns in widely-used local products, and your users’ familiarity with technology in general. I’ve often deviated from our brand and design system guidelines when designing for Lyft’s instance of Flex, because interaction patterns that Lyft riders in the US are familiar with don’t necessarily translate to a web app being used by support agents in Colombia who have never even taken a Lyft ride. The lesson here is to keep the design simple and standardized to a level that anyone, anywhere can pick it up and quickly start using it. It goes a long way in building their confidence in the system if they’re able to get comfortable with it quickly from the day they start on the job.</p><h3>3. Optimize workflows for efficiency where possible</h3><p>A very common problem that designers run into when designing for efficiency in internal tools is that the view starts to get crammed with dozens of features because hiding options and actions in menus or layered interfaces hurts the usability of the tool. Product Managers will often expect designers to “solve” the problem of keeping the tool usable while they add thirty new features in one year, each with their own dedicated button or trigger for a flow. But as we likely know, every new CTA or text link that isn’t essential to the workflow in that moment is just extra added noise, accumulating onto the design debt already present in the screen.</p><figure><img alt="The most common actions on the view (ending a chat, sending a message, and completing a case) were scattered across the view, creating a large work triangle for mouse movements." src="https://cdn-images-1.medium.com/max/1024/1*9BuonqhE4XP3n0Xjtvu7fw.png" /><figcaption>The most common actions on the view (ending a chat, sending a message, and completing a case) were scattered across the view, creating a large work triangle for mouse movements.</figcaption></figure><p>In Lyft’s instance of Flex, we ran into an issue where the most commonly used actions were spread out very far from each other, creating a large and inefficient <a href="https://en.wikipedia.org/wiki/Kitchen_work_triangle">work triangle</a> on the screen to accomplish the most frequently used workflow. We couldn’t move the buttons closer together due to many technical constraints relating to how the view is laid out, so we took a different approach — adding keyboard shortcuts. Instead of needing to move the mouse in a large spread out triangle to hit all these different buttons, users could just use keyboard shortcuts to trigger those actions, all without ever touching the mouse. This worked out especially well because agents were typically typing responses to customers in the chat window and had their hands on their keyboard anyway. This resulted in a significant improvement in resolve time for agents that leveraged keyboard shortcuts in their work.</p><h3>4. Test your designs to uncover real-world differences</h3><p>Due to the low visibility of internal tools, they can often get dismissed by senior leaders as non-essential. They might tell you that they don’t <em>really </em>need to be usability tested or that it’s okay for them not to work as well as their consumer software. This is a really flawed lens to look at tooling from, because designers are making assumptions about user behavior when designing for internal tools in the same way that the designers making consumer products are. The consumer products benefit from having their designs thoroughly vetted in usability testing but internal tools often don’t. There’s just as much to learn about the shortcomings of a design in tooling as there are in consumer products, and they should be treated equally in terms of the level of attention and care given to them. If you don’t test the designs, you risk overlooking really important things about how your users are using the software — this applies to both consumer products and internal tools.</p><figure><img alt="Lyft’s support tooling is a high-density view with lots of essential information shown on-screen at the same time. Responsive design played a big role in ensuring that all UI elements scale correctly." src="https://cdn-images-1.medium.com/max/1024/1*7gIVTwdq0DqS8t7AXbIHzg.png" /><figcaption>Lyft’s support tooling is a high-density view with lots of essential information shown on-screen at the same time. Responsive design played a big role in ensuring that all UI elements scale correctly.</figcaption></figure><p>I started at Lyft right at the beginning of the pandemic when everyone started working from home, including our support agents. The design principles we had been using worked great when we knew what the work environment for our support agents was — they had designated monitors with standard screen sizes and network speeds. But when they all started working from home, everything fell apart. My designs were being used on multiple square monitors with low resolutions and at varying screen widths, leading to strange layout bugs and text scaling problems. We only uncovered these issues by observing our agents use the product via screenshare in shadowing sessions as they worked from home. The insights led me to create fully responsive designs for Flex because of the limited square-ish screens our agents had at home. Responsive layouts hadn’t been a priority for the team before because we knew that agents were working off of wide monitors in an office environment, but we now started prioritizing it after seeing how the designs fell apart in a WFH setting with different monitors and setups. The design isn’t “complete” until you observe your users accomplish their task and solve their goals in it, so make sure you actually watch them use it.</p><h3>5. Unify the fragmented frontend experience</h3><p>Internal tools are typically comprised several different microservices all hooked up together elegantly masquerading as one app or product. In the backend, they’re entirely different codebases which, at an enterprise-level scale, could be owned by totally different engineering teams. The challenge for the designer here, then, is to make the interface “feel” like one unified experience to the user and hide all the complexities of the fragmented frontend from the user. It can be particularly difficult to pull this off, especially if our project desperately needs a specific tweak to a part of the code that your team doesn’t directly own.</p><figure><img alt="GIF displaying the visual evolution of Flex from over the course of three years (2020, 2021, and 2022). Shipping small changes over time throughout various projects ensured that we could work towards our northstar vision." src="https://cdn-images-1.medium.com/max/1024/1*VTqsP_tCk0owh1emP8_oZA.gif" /><figcaption>GIF displaying the visual evolution of Flex from over the course of three years (2020, 2021, and 2022). Shipping small changes over time throughout various projects ensured that we could work towards our northstar vision.</figcaption></figure><p>Lyft’s instance of Twilio Flex was particularly notorious for this. There were several UI elements that I wanted to standardize and streamline, but many of the components like the side nav and the header existed in parts of the Twilio codebase couldn’t be customized or changed. As a result, I couldn’t quite leverage <a href="https://design.lyft.com/building-a-design-system-library-3a1f0d09088f">Lyft’s LPL design system</a> and had to do something different. We ended up creating our own design language for Lyft’s instance of Flex that only made sense for this one product because of all the technical constraints we were working under. We managed to ship big facelifts by updating various pieces of the UI whenever that interface element was being worked on as part of a project. I had a northstar design vision for Flex and pushed to update specific UI elements through various projects until we finally got there. Our product now mostly feels like one tool, even though it’s several different pieces of software loosely hooked up together with a standardized interface.</p><h3>6. Designing for power users vs. first-time users</h3><p>As you talk to your users about your internal tool, you’ll undoubtedly get some strong opinions from long-time users. These power users will ask for more integrations, more shortcuts, multitasking views, and more. These are all great for efficiency, but make sure not to neglect the FTUE (first-time user experience) by overloading the view with power user features. It’s too easy to get carried away and veer too far into the hyper-efficiency end of the spectrum, but always step back and ask “<em>How would a new user be onboarded to this feature?</em>” If the answer seems too complex or unclear, it’s probably worth re-visiting whether that feature is really needed or not.</p><figure><img alt="Lo-fi wireframes for a “suggested replies” feature that didn’t make it past the early design ideation phase. We chose not to build a power user feature and reduce friction associated with a complex interaction." src="https://cdn-images-1.medium.com/max/1024/1*Ed4pOS33I3f4E8QkOezFCg.png" /><figcaption>Lo-fi wireframes for a “suggested replies” feature that didn’t make it past the early design ideation phase. We chose <strong>not</strong> to build a power user feature and reduce friction associated with a complex interaction.</figcaption></figure><p>In Lyft’s Flex instance, we heard a lot of requests for features like canned responses and message templates. Agents were spending a lot of time typing out the same message to customers with minor variations in each one, and they really wanted to be able to have them all saved somewhere in the view that they could easily copy &amp; paste from. In fact, they already had spreadsheets with these message templates open on a separate screen. New users, on the other hand, would never ask for something like this. They haven’t spent enough time in the tool for this to become a problem. As we started exploring ways to build this out, we realized that no matter what solution we came up with to integrate message templates into the view, we wouldn’t be able to match the level of customizability and formatting options offered by spreadsheets and other notetaking apps. Power users were already utilizing these and had built their own custom workflows for it in spreadsheets, so we made the decision to <em>not </em>build this feature. We avoided cluttering our view with more features by making the tough choice to <em>not </em>build something, which isn’t as common as it should be in the world of tooling.</p><h3>7. Stress test with admin and operational features</h3><p>An interesting component of internal tooling is the administrative side of the world, or the “admin backend.” Team leads and supervisors managing the people using the tool need performance management dashboard views or special admin override settings. Ideally, the regular non-admin view should scale to include admin features or share a set of design components that seamlessly scales with permission layers granted to users.</p><figure><img alt="A wireframe for an “unassigned cases” view from where supervisors can keep an eye on how their agents are doing. Team leads can also jump directly into chats from here and interact with customers." src="https://cdn-images-1.medium.com/max/1024/1*1_2W9UeHK0eTXGd9gHJIaA.png" /><figcaption>An old wireframe in Flex for an “unassigned cases” view from where supervisors can keep an eye on how their agents are doing. Team leads can also jump directly into chats from here and interact with customers.</figcaption></figure><p>In Lyft’s support tools, experienced team leads that don’t normally work any chats will sometimes have to step in for especially problematic cases. These leads will often jump directly into a chat and work on it just like a regular agent would. These leads have special privileges that regular users don’t, like being able to “force end” a chat where customers are being abusive towards the support agents. I designed our UI to ensure that every interface element could accommodate these special options for admins while still working smoothly for the regular users. We designed views in the UI where team leads can monitor the health of their service level agreements and have a general level of visibility into all the active ongoing cases. Ensuring that your designs scale to this extra operational layer is a crucial component of designing internal tools that typically isn’t as top-of-mind when working on other consumer products.</p><h3>8. Ship changes slowly and cautiously</h3><p>If your internal tool has existed long enough, your users have most definitely created very specific workflows and hacks to use it in the way that works for them the best. They’ve likely developed a muscle memory of how to access common menu items and all the common bugs or issues that might pop up. When you ship new changes and suddenly change where things are, your metrics can take a huge hit because all users are now re-learning the software. Be prepared for this and don’t expect a sudden improvement in what you’re measuring as soon as you ship a change. In fact, the opposite is likely to happen — your metrics will move in the wrong direction for a while until your users reach the same level of familiarity and understanding with it as they had with the previous version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_J5zVqT5rv-VcV7BsnYz1A.png" /><figcaption>Testing sound notifications with beta testers in a live environment was essential to uncovering issues with sound permissions on the OS as well as the browser, leading us to adding additional options.</figcaption></figure><p>For shipping changes to Lyft’s instance of Flex, we found a good rhythm to this by first shipping the new changes to a handful of beta testers who were spread out across our various support locations around the world. These were a mix of experienced, technically proficient users along with some newer users who weren’t as familiar with the software. Testing the build with them first allowed us to address any major issues and fix them before shipping it out to all Lyft agents. These fixes sometimes took the form of simple copy changes whereas other times required the implementation of an intensive onboarding flow or a guided first-time user experience. Testing with this core group before shipping to everyone was critical in us developing a high level of confidence for the success of the features.</p><h4>Wrapping up</h4><p>Well-designed internal tools are crucial for the success of an organization, especially at scale. They need to be designed with just as much care as consumer products, only with a different set of end goals. It’s important to stress here that not all the tooling problems can be magically solved just by staffing the team with a designer. There needs to be a robust product development process that includes strategy, ideation, prototyping, concept testing, and beta testing. All the varying levels of technical constraints and product considerations means that designers need to partner very closely with Engineering Managers and Product Managers to pull this off well.</p><p>Working as a designer on tools can feel particularly difficult, especially when the changes you know are needed in the tool don’t exactly align with the business priorities of the organization. It takes some clever integration of small changes to ship piecemeal UI updates through varying projects, a muscle that designers can slowly develop over time. One of the benefits of working on internal tools is that they’e naturally lower-visibility than the consumer-facing side of the business, so you have the ability to be a bit more scrappy and move faster, as long as you aren’t compromising on user workflows or efficiency.</p><p>I hope this has proved useful in shedding some light on what it takes to work on internal tools as a designer. It’s often complex and tricky work, requiring a very specific skillset from designers that they can quickly learn and develop even if they don’t possess it from the outset. Better tools mean better experiences for their users, which in turn translates to better customer experiences. Feel free to reach out if you have any further questions about my experience designing internal tools. Happy to answer them. Cheers!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0500fcb9277" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling Lyft’s Ride History]]></title>
            <link>https://medium.com/@a_kill_/scaling-lyfts-ride-history-7d3d4cb41291?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d3d4cb41291</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[case-study]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Tue, 13 Dec 2022 23:42:46 GMT</pubDate>
            <atom:updated>2022-12-13T23:42:46.761Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C6PkDokT7XSi-RrKKegSpA.png" /></figure><p>This was a project I felt would be worth writing about because my experience with it highlights a lot of modern product design processes quite well. Designers joining organizations today are often asked to redesign an existing feature that has long outlived its purpose, and it can be a tricky act to pull off because you inevitably run up against many headwinds throughout the process. Stakeholders and VPs continually question the priority of the initiative, PMs and Data Scientists want to change as little as possible to ensure valid experimentation results, and you’re left making design decisions without enough context from the purpose and vision of the original design.</p><p>Such was the case with Ride History, a view within the Lyft app that I’m sure you’ve accessed at some point. It’s a seemingly innocent screen from the outside as a user, but internally at Lyft, it was messy. There wasn’t a dedicated team or owner for this view and many teams had been shoving features in there without a clear view of how all the information is organized. Many had strong opinions of what the view should and shouldn’t do, while I as the designer expected to “plant the flag” of what the future of this view was as Lyft scaled to be a multimodal transportation app incorporating a lot more than just rides in the view.</p><p>Additionally, a good chunk of the work I did on this project did <em>not</em> make it into users’ hands. But still, it’s worth highlighting exactly how much work and thinking goes into something only to get shelved at the eleventh hour due to resource/budget constraints or top-level company initiatives changing. Designers are running into this a lot these days, but it shouldn’t take away from the fact that it’s still valuable, real design work. So I figured it’s worth writing about. Hope you find it insightful.</p><h3><strong>Context</strong></h3><p>If you’ve ever lost something in a Lyft ride or if you’ve had to report an issue about a particularly concerning experience in a ride, chances are that you’ve opened up your Ride History to look for the ride and get help on it. Lyft’s Ride History logs all of your past rides and combines rides that were taken in the same day into one charge. In the detailed view of a ride, you can see the route your driver took, see an itemized breakdown of the payment for the ride, and get support for any issues related to the ride.</p><figure><img alt="From the home screen, open the side menu and tap on Ride History to see all your past rides. From there, tap into a ride to see the detailed view of a ride. In Ride Details, scroll down to get help or report a safety issue to proceed with support flows." src="https://cdn-images-1.medium.com/max/422/1*yUhZtHnCKq3esPzFvQowAw.gif" /><figcaption>The existing Ride History screens in the Lyft rider app</figcaption></figure><h4>The problem with Ride History</h4><p>Having spent the last two years working on the support experience for Lyft users, I learned that nearly <strong>40% of all reported issues on Lyft rides start from Ride History</strong> (with the the rest of them coming from the post-ride rating experience and direct outreach from the in-app Help tab). Despite this, Lyft’s Ride History hasn’t changed much over the years, save for minor visual updates. We prioritized a redesign of the view to solve several problems:</p><p><strong>1. Ride History hasn’t scaled with Lyft’s evolution:<br></strong>Lyft’s<strong> </strong>product offerings have nearly tripled in size compared to five years ago. We now have rentals, Lyft Pink memberships, e-bikes, vehicle repair services, and many new offerings on the way. We’ve been shoehorning all of these into the existing Ride History view without having taken a holistic look at how they all fit together, and it was time to finally address how this surface should accommodate all of these transportation offerings that go beyond a “ride” and branch into broader offerings like service, transactions, and memberships.</p><figure><img alt="Lyft’s 2017 rider offerings: Lyft rides, Shared rides, Scheduled rides, Business rides. Lyft’s 2022 rider offerings: Lyft rides, Shared rides, Scheduled rides, Business rides, Bikes &amp; eBikes, Scooters, Rentals, Transit, Riders for others, Vehicle service, Parking, Roadside assistance. Lyft’s 2017 payment offerings: Credit cards, debit cards, coupons, Gift cards. Lyft’s 2022 payment offerings: Credit cards, debit cards, coupons, Gift cards, Daily Billing, Lyft Cash purchases, Lyft Pink membership" src="https://cdn-images-1.medium.com/max/1024/1*Hhy3g6mcUh87g39AiA-IvA.png" /></figure><p><strong>2. It’s difficult to find a specific ride in Ride History:</strong><br>Today, Lyft riders come to Ride History to find a ride to review charges on or get help on, but unless that ride is very recent and is at the top of the view, it’s a bit of a hassle to find it. You’d need to scroll down quite a bit and recall a unique identifier about that ride to quickly identify it in the list. There is also no way to filter the view by ride types or dates to directly jump to a specific ride that you want to. And even if you do find the ride, access to help is somewhat buried and it doesn’t display any outcomes or resolutions that may have already taken place about that ride.</p><p><strong>3. Ride History lacked visual consistency:</strong><br>We display the driver’s profile photo if it’s a regular Lyft ride but we show the respective vehicle imagery for bikes, scooters, or rentals (and a vehicle image looks especially odd in a small format). New offerings don’t have a defined pattern of fitting into this model, so we needed to streamline the visual language of this view. Research has also shown us that the current display of how multiple rides in a day are charged together is confusing to riders, so we wanted to address this as part of the redesign as well.</p><figure><img alt="Ride History had limited filtering options, unclear information priority, no visual consistency, and a Daily Billing model that caused confusion" src="https://cdn-images-1.medium.com/max/1024/1*OcMMTktd4l_KFOYddOZX5Q.png" /><figcaption>The problems with Ride History, summarized</figcaption></figure><h4>Our framework</h4><p>I partnered closely with the Product Manager to define a <strong>platform approach</strong> for this project, where we would create the template for how Ride History could scale to handle all of Lyft’s offerings. One of our first proposals was to rename the view from “Ride History” to the more generic and all-encompassing “History” so that we can display more than just rides in the view.</p><figure><img alt="A breakdown of Lyft’s lines of businesses and offerings" src="https://cdn-images-1.medium.com/max/1024/1*XmDYrUyHVaUcwExX5qxbgg.png" /><figcaption>Mapping out all of Lyft’s LOBs (Lines of Business) and their offerings</figcaption></figure><p>We laid out all the different types of rides, transactions, and services that the new “Lyft History” would need to house and conducted several interviews with internal stakeholders at Lyft across all of our lines of businesses to better understand the gaps in the current Ride History experience. Some of the biggest takeaways from these sessions were that there was an overall desire from many teams to <strong>use Ride History as an educational surface</strong>, <strong>increase clarity about potential savings</strong> and best practices, and <strong>reduce user-initiated chargebacks with their banks</strong> by providing a clear path to resolution through Lyft. We sought to address as many of these pain points as we could in our redesign.</p><h3>Part I: Conceptual exploration</h3><p>As we embarked on the redesign, it became clear to us that many things were unclear. For instance, the information we currently displayed in each row to identify a ride didn’t seem that useful. We showed the driver’s profile picture, the type of the ride, a Personal/Business descriptor, the pickup time, the total ride length, and the total cost. Are all of these useful in identifying a ride? If we had to narrow it down, what are the top two or three things the riders actually cared about? We decided to run an initial round of research sessions to get answers to these questions, and I started tinkering with some concepts to put in front of users for these sessions.</p><h4><strong>Initial ideation</strong></h4><p>One of the most useful exercises you can do at the beginning of each project is to temporarily ignore the business and user constraints. What are all the ways in which you could design this screen? How could this view evolve from just a boring list of rides into something totally different? This kind of freeform ideation helps surface the seeds of ideas that would otherwise never come to light. It’s important to clarify that <strong>none of these early concepts were based on insights or data, they were just explorations to test the boundaries of the problem space and spark new ideas as we continued to iterate.</strong></p><figure><img alt="Fig 1: A timeline view of rides you’ve taken in the day, Fig 2: a historic routemap of all rides you’ve ever taken, Fig 3: card-based layout grouped by trips" src="https://cdn-images-1.medium.com/max/1024/1*Hbl7f2vEUBV7-LRlBlSdPg.png" /></figure><p>Some of my earliest concepts were intentionally “out there”, one of which was a <em>Google Maps</em>-esque timeline view of rides taken in a given day (Fig 1). This concept loses its utility for people who only take one or two rides occasionally and has the added downside of forcing repetitive user interaction to view older rides, but regardless, there’s something interesting about seeing a breakdown of your day across different modes of transport with Lyft.</p><p>Another concept combines all rides you’ve ever taken into one densified historic routemap (Fig 2), logging total miles and places visited before going on to list out all the rides below. It paints a pretty striking visual of the places you most frequently visit and parts of the city that you’ve explored more than others, but it also becomes less useful when the majority of a rider’s rides are between their home and work/school. This concept also falls apart when you’re a business traveler who takes a lot of rides in multiple cities, forcing you to constantly switch regions to view all your rides.</p><p>The final concept (Fig 3) groups individual rides into the idea of “trips,” catering to the riders who frequently take roundtrips from their home to a specific place and back, or those who hop around a new city exclusively through Lyft. There’s a strong connection here to how our daily billing model works and aggregates charges, but it forces a big shift in a rider’s mental model to think in terms of grouped trips instead of individual rides. It also makes it more difficult to find specific rides when they’re grouped together as opposed to just seeing them listed out individually.</p><h4>Filters and search</h4><p>Returning to reality after some of the big-picture ideation, I decided to tackle the simpler stuff. How would filtering work in this view? What kinds of filters do we even need? Which ones would riders care about the most? Would search work better, and if so, what search queries would a rider use to find rides? We were planning to ask all of this in research sessions, but I was simultaneously putting together some early design concepts for these too.</p><figure><img alt="Explorations for filters and search in Ride History" src="https://cdn-images-1.medium.com/max/1024/1*4qWSyikNRYc_Fir2Xnlzng.png" /></figure><p>Our <a href="https://design.lyft.com/building-a-design-system-library-3a1f0d09088f">Lyft Product Language</a> design system makes it a breeze to quickly spin up iterations for a design. Working on filters bought up many questions throughout the design process, like what we should even allow users to filter on and whether they should be single-select or multi-select. Exploring filters also swiftly eliminated many of the problematic bigger-picture ideation that I was tinkering with earlier, since filtering out rides from any of those views could break the experience significantly. <strong>Simultaneously working on different problems in the same view can help ensure that a solution to one problem doesn’t cause a design conflict with the solution to another problem, especially if they need to work together on the same screen.</strong></p><figure><img alt="Exploration for filters" src="https://cdn-images-1.medium.com/max/1024/1*E83w0BnNab_Zt9MR5YIopg.png" /><figcaption>Early explorations for how to display filter toggles (grouped or flattened), use overlays to quickly apply specific filters, and the “All Filters” view where multiple filters can be applied at once</figcaption></figure><h4>Visual display of a ride</h4><figure><img alt="Various explorations for card-based layouts" src="https://cdn-images-1.medium.com/max/1024/1*mmn6Lwuy9-PiuojqvAEGdQ.png" /></figure><p>Even though the grouped trips exploration didn’t go anywhere, it led to this interesting idea of using a card-based UI to display rides. These containers could cleanly delineate a ride or a set of rides in a given day, and there was something appealing about using larger visual imagery to quickly identify the ride instead of combing through ride descriptors to identify the ride, and so I went down a rabbit hole of explorations to try and display all the primary information of a ride in varying card-based styles.</p><figure><img alt="More visual explorations for card based layouts" src="https://cdn-images-1.medium.com/max/1024/1*ZgLri--WHduFInYXZP1y9A.png" /></figure><p>After working on several iterations of potential layouts, I felt like I had something worth putting in front of users as we interviewed them about identifying rides during research sessions. I landed on a model where regular Lyft rides would show the vehicle imagery along with the driver photo, whereas bike rides, scooter rides, and rentals would show just the vehicle imagery on the right. Giving more visual prominence to the vehicle imagery felt like an interesting approach, and I was curious to see how this would test with users.</p><figure><img alt="Card based layouts combined with new filter explorations" src="https://cdn-images-1.medium.com/max/1024/1*BvHEB0W1EzmV2NYdcUwqHA.png" /></figure><p>As a side note, I sort of ran out of time to try and incorporate the additional types of offerings in here. What would service visits and Lyft Pink membership transactions look like here? Would they fit into this heavily visual redesign? I wasn’t expecting the iteration for individual rides to turn into a deep exploration involving several rounds of iteration and feedback, so we decided to temporarily descope those offerings and come back to them in the second round of design revisions (more on that later).</p><h4>Concept testing and feedback</h4><p>I put together an interactive prototype that our amazing UX Researchers tested with real Lyft riders to gauge their reaction to the new designs and better understand how they thought about past rides. <strong>The imagery-focused approach seemed to work, but at the detriment of clarity.</strong> Riders didn’t seem to understand why some rows were showing driver photos but others weren’t. They didn’t make the connection that rentals only displayed the vehicle image and rides displayed the driver photo in addition to the vehicle image. In short, <strong>users weren’t reading the text descriptors but were only looking at images to identify the rides.</strong></p><p>We also learned that filters titled “Rideshare” didn’t mean much to riders who exclusively used Lyft for just rides to and from places (which is a significant portion of Lyft’s userbase). They suggested just calling this filter “Lyft rides” or something clearer. Many participants also called out that daily billing total amount and the payment method took up a lot of space on the screen, while also calling out that it’s not immediately relevant to their needs when coming to this view to review past rides. Finally, all participants quickly and instinctively understood the transition of “Ride History” to “History,” increasing our confidence in renaming the view as we added more offerings.</p><figure><img alt="Before and after designs for the first round of concept testing" src="https://cdn-images-1.medium.com/max/1024/1*bxlvTTS8ZKRk4miTdYhkmg.png" /></figure><p>I also presented these designs internally to our Design Leadership Team, which was another great forum for visibility into the work. Their feedback was that this <strong>imagery-first approach isn’t quite solving the inconsistent visual language problem</strong>, with the images still causing the viewer’s eyes to zig-zag all over the place as they tried to figure out why some rides look different than others. The Design Leadership Team also encouraged me to really question if the vehicle image is a strong visual anchor for riders to recall past rides or not, because we needed to justify the increased visual prominence given to the vehicle imagery. Lastly, they reiterated the transactional and utilitarian nature of the view as a place where riders come to review past charges and get help, which meant that we should likely strive to <strong>maintain a receipt-style list of rides with charges on the right side </strong>and potentially explore clear, streamlined iconography to represent the variations in offerings instead of using flashy, visually heavy cards that could feel extremely overwhelming in stress cases.</p><h3><strong>Part II: Refined iteration</strong></h3><p>As it is with most design work, you won’t get it right the first time. The concept we had was primarily to foster insights and discussion about what we should or shouldn’t be doing in this redesign, so we were now armed with lots of great research findings and internal feedback to properly tackle the design. I split up the work here into three broad buckets to tackle in chunks:</p><ol><li>Daily Billing</li><li>Filtering</li><li>Iconography</li></ol><h4>1. Daily Billing</h4><figure><img alt="Daily Billing (combined charges) in the current Ride History view" src="https://cdn-images-1.medium.com/max/1024/1*ToV0wEP7byH6Qx3oeSEQaA.png" /></figure><p>I wanted to dive deep into how to visually indicate charges that were combined together. To save riders money on swipe fees charged by credit cards, Lyft aggregates all the rides you take in a single day and charges your card once at the end of the day. The way we display these in Ride History today is not intuitive to users, especially when there’s multiple payment methods being used in a day across personal and business profiles.</p><figure><img alt="A table of things that are and aren’t included in our Daily Billing system" src="https://cdn-images-1.medium.com/max/1024/1*RJlYXtifc9dn-k5BhviU_w.png" /></figure><p>In discussions with the Pay team at Lyft, we learned that <strong>only high-usage, high-volume offerings would be combined and charged together</strong>. Other low-volume offerings like rentals, that have high per-transaction costs but are used infrequently, would never be combined and charged with other rides as part of the daily billing model. Business rides would also never be combined together in daily billing, since those use a different payment method. This added an extra constraint to the Lyft History designs, since the view now <strong>needed to work for offerings that may or may not be charged together as a combined charge.</strong></p><figure><img alt="Early explorations for how to display combined charges" src="https://cdn-images-1.medium.com/max/1024/1*sAQ0nujyo0mky-98Y2RpDg.png" /></figure><p>I began exploring ways to maintain the receipt-styling with charges on the right side while also trying to indicate combined charges in some form. I explored several options where we didn’t explicitly call out which charges were combined together (Concept A), called out combined charges in the middle of the rows (Concept B), and pushed the complexity of Daily Billing into an entirely separate view buried one level deeper (Concept C).</p><p>Our Pay team partners were quick to point out that we had past research that indicated a <strong>rider preference for seeing the exact combined charge amount on the main view</strong>, which immediately eliminated the third option (Concept C) as a viable approach. To understand why, let’s paint a picture. Alice, a Lyft rider, takes three rides in a day and is charged a combined total of $60 for those three rides. Alice will see $60 charge from Lyft in her card’s bank statement. If Alice isn’t aware of the fact that it was a combined charge for three rides, she’ll come to Lyft’s Ride History looking for a $60 charge. If she doesn’t see the $60 charge, she’ll dispute the charge with her bank, resulting in a costly and expensive chargeback for Lyft. <strong>Many riders want to see the exact numbers they’re seeing in the bank statement matched one-to-one in the Lyft app, so it was essential that we display the combined charges on the main History view.</strong></p><figure><img alt="Stress testing the explorations for how combined charge displays work with multiple filter sets" src="https://cdn-images-1.medium.com/max/1024/1*3ySZWgmk4Ox97B_E62WobA.png" /></figure><p>As I was exploring various ways to display combined charges on the main History view, I was running into several issues. We still needed the individual ride or transaction details to be accessible from the main view, since we needed riders to be able to quickly access the detailed view of a ride. I also <strong>needed to clearly indicate to riders that the combined charge is not an <em>additional</em> charge but instead just the total of some of the individual charges in that day that were combined together</strong>. This was a tricky design problem. I explored ways to emphasize the combined charge rows more than the individual rides by differentiating the typography and visual density of the rows, but it still wasn’t coming across as clearly as I wanted it to.</p><figure><img alt="Inspiration: Connector lines on Twitter to indicate related content" src="https://cdn-images-1.medium.com/max/1024/1*NOZ7tnksddAHhVReFTkK4g.png" /><figcaption>Connector lines in Twitter allow users to keep track of replies to a specific conversation thread</figcaption></figure><p>While looking for design inspiration, I ran in to some interesting examples of other products trying to indicate related content in a high density view. Twitter uses line connectors to visually link conversation threads, guiding the viewer’s eye to a reply on a specific tweet and making it easier to follow along a train of back-and-forth replies. It even handles accessibility issues well, with screen readers reading out “<em>Replying to…</em>” when they hit the line connector, allowing blind or visually impaired users to follow along with the conversation in the same way sighted users can. So I gave it a shot in my design.</p><figure><img alt="Continued explorations of combined charge layouts with connector lines" src="https://cdn-images-1.medium.com/max/1024/1*psUcXRv9eTVcM2sKufBqyQ.png" /></figure><p>The connector lines seemed to work fairly well as visual links that indicated combined charges. I tried a few variations, some of which looked too much like branching paths while others felt too much like an activity timeline. Overall, I was trying to ensure that <strong>uncombined charges would stay separate without the line going through it while the rest of the combined charges would have the line passing through it.</strong></p><p>Even with this connector styling, another big problem I seemed to run into with the differentiated density and visual styling for combined charge rows and the individual offering rows was the transition when certain offerings are filtered out. We were adding filters to the view, so <strong>what happens when the user filters out an entire type of offering? </strong>The “Combined charge” would be inaccurate and wouldn’t match the sum of the charges, so we’d have to remove it. Then what happens to the styling of the condensed offering rows within a combined charge and the default offering rows that weren’t combined? We’d have to maintain two different list item styling as filters are added and removed, contributing to rapidly switching layouts and re-ordering of the rows, adding to even more confusion. So I decided to kill the differentiation between rows and keep it all consistent.</p><figure><img alt="Final grouping UX of combined charge layouts" src="https://cdn-images-1.medium.com/max/1024/1*7cuNTgpVNtQCuydpfQ-oPQ.png" /></figure><p>In the final proposed daily billing grouping, I had all the offerings maintain the same styling regardless of whether they were part of a combined charge or not. This way, <strong>the only changes when filters are applied would be that the connector lines disappear and the combined charge rows disappear.</strong> We’re then left with a static list of offerings that the user filtered by. We don’t have things changing their visual display density anymore based on whether or not filters are applied. This also made good UX sense because <strong>once a user starts applying filters, their use case has changed from reviewing combined charges to finding a specific ride.</strong></p><p>The Pay team loved the new direction. This visual connector for combined charges made it immediately clear which offerings were and weren’t charged together in a single transaction, while also elegantly maintaining the design language when users applied filters to find individual rides. Overall, I was also pretty content with how it managed to stick to the receipt styling while improving the comprehension of our daily billing model.</p><h4>2. Filtering</h4><p>Speaking of filters, this was the next big chunk of work I wanted to focus on. There’s three main use cases we had identified for filters:</p><ol><li><strong>Finding a specific old ride to get help on</strong> (or report a safety issue on)</li><li><strong>Finding a specific Personal or Business ride to fix misattribution</strong> (for users who may have mistakenly taken a Personal ride on a Business profile, or vice versa)</li><li><strong>Reviewing charges for offerings of a certain type to ensure accuracy</strong> (ex: filtering by bike rides to quickly see all bike charges at-a-glance)</li></ol><figure><img alt="List of proposed filters for the design" src="https://cdn-images-1.medium.com/max/1024/1*W0E8YS71q5DeAYKniND7qg.png" /></figure><p>Our first goal here was to figure out which filters would be most useful for riders. Thankfully, we had great insights here from our initial round of research. We knew that we’d keep the <strong>Personal/Business filter </strong>that already existed on the view, since it solved the misattributed rides problem. We wanted to add in a <strong>“Type” filter </strong>that would allow users to filter by offering type, narrowing down the list significantly when riders filter by a specific transportation mode. We also wanted to add <strong>timeframe</strong> <strong>options</strong> to filter the list by, allowing users to select from rides within a date range or just see rides taken before the last year or last few months (with the justification being that recent rides are easily accessible by simply scrolling for a bit). Initially, we assumed that adding a <strong>star ratings filter</strong> would be useful, hypothesizing that low-rated rides would correlate to rides that likely require support issues, but discarded the idea after some digging into data insights revealed that there was no link between ride rating and support tickets on a ride.</p><figure><img alt="Type filter explorations (single-select vs multi-select)" src="https://cdn-images-1.medium.com/max/1024/1*jqnzQzKz-soixbnH9RWyLw.png" /></figure><p>One of the tough design decisions I had to make here was whether or not we should offer a multi-select option in the Type filter, or if they should all be single-select. I could not think of a use case where a rider would want to filter by bike rides as well as rentals to view all of their bike rides and rentals at the same time. Researchers, Product Managers, and Data Analysts at Lyft also backed up my theory that there isn’t a strong use case there, so I decided to <strong>keep them all single-select only.</strong></p><figure><img alt="Timeframe filter explorations" src="https://cdn-images-1.medium.com/max/1024/1*9L-b6is-wsPZvX20F8xN5g.png" /></figure><p>Another tricky filtering decision was the timeframe filter. My first choice here was to offer options in buckets of time going back from a month, i.e, allow filtering by “Older than a month” vs “Older than 6 months,” etc. This confused every single person I showed it to internally, with everyone questioning why we weren’t just saying “Within a month” vs “Within the past 6 months” and were instead offering the reverse. My answer to this was that <strong>recent rides within the past few weeks or month could easily be accessed by scrolling down a bit in the view, but finding specific rides that are older required a lot more scrolling</strong>, so an “Older than…” filter elegantly solved that problem. Gmail offers a timeframe filter exactly like this for the same reason. Even though people understood it after I explained it, it wasn’t a good sign that it seemed confusing at first sight and always needed further explanation (which is typically an indicator of it needing to be reworked). So I <strong>changed this to be a custom date range filter</strong>, allowing users to pick specific buckets of time to create their own timeframe ranges to filter by.</p><figure><img alt="Final filtering designs" src="https://cdn-images-1.medium.com/max/1024/1*oz5NV552CwrSmn79nRaqbQ.png" /></figure><figure><img alt="Final filtering designs" src="https://cdn-images-1.medium.com/max/1024/1*1nDp0aOkyGCeGdItvwZXRA.png" /></figure><p>The final proposed filters list worked as an “OR” filter within each filter bucket and as an “AND” filter across the filter buckets, i.e., you could only pick one filter within each group and apply them in combination with the other filters. We felt that this <strong>MVP set of filters would provide a robust enough set of options for users to filter by and find specific rides</strong>. The “All Filters” view displayed the same set of filtering options that could all be selected and applied at once instead of individually triggering the quick filter panels. I also created empty states, along with special variations of empty states for Lyft Pink and Lyft Business, honing in on those team’s desire to use these surfaces aa educational entry points to those offerings. A special thanks to Kevin Kwong from our illustration team for these amazing brand illustrations!</p><figure><img alt="Empty state designs for business profile and Lyft Pink filters" src="https://cdn-images-1.medium.com/max/1024/1*5uB5CiHggbPlN57GNtE9zw.png" /></figure><h4>3. Iconography</h4><p>It was finally time to fill in those empty gray circles with icons. We already had several icon sets in our illustration library, courtesy of LPL. My task here was to just figure how to best incorporate them into this new layout in the way that clearly distinguishes offerings from one another.</p><figure><img alt="Iterations and variations of iconography" src="https://cdn-images-1.medium.com/max/1024/1*3a0P1a_S-BMtsME1vPdYcQ.png" /></figure><p>There were many ways to go about it, but I <strong>ended up liking V1 the most</strong> (as did the rest of the team). The filled-in circular frames drew less attention to the outline while still providing a base for the icons, and avoided the issue of looking too much like a route line or activity timeline. The connector lines also played the most nicely with this version, so I ended up sticking with this in the final design. Internal stakeholders encouraged me to stress test this design in states where riders typically use the same offering, say for example, riders who only take Lyft rides and never engage with any other mode of transportation offered on Lyft. We did this, and it revealed another big problem with the design.</p><figure><img alt="Stress testing History view with repeated offerings in view" src="https://cdn-images-1.medium.com/max/1024/1*J_A36ClU4wUALltQorOcXA.png" /></figure><p>For riders who often engaged with just one type of offering (like just Lyft rides), <strong>there’s almost no visual differentiation in the view</strong>. All of them would have the car icon and all of them would say “Lyft Standard.” At least in the old design, the driver profile pictures provided a bit of visual differentiation (although their usefulness was debatable). Now, we’re relying on the date, time, and price to do all the heavy lifting of differentiating the ride. To address this issue of visual sameness, I shared the designs with the rider team at Lyft to try and come up with a solution.</p><figure><img alt="Stress testing History view by using destination address as a text differentiator" src="https://cdn-images-1.medium.com/max/1024/1*YT84uSami3MtkvdwzIzoHw.png" /></figure><p>The rider team had a great suggestion. Instead of solely relying on the mode name of the ride, we could also <strong>display the destination address for the ride</strong>. According to past research, the requested destination is a strong mental anchor for riders to recall past rides, so this served as an additional piece of differentiation for rides. I was debating whether to keep this as the primary text or display it as subtext, so I had two versions to concept test here.</p><p>At this point, I shared out the designs with several internal stakeholders across almost all the different lines of business at Lyft, made some minor tweaks and edits based on feedback, and put together a refined prototype for concept testing.</p><h4>Concept testing</h4><p>Our objectives with this round of tests were to assess how well riders understand the new daily billing model in the new designs, gauge how they feel about seeing iconography as compared to the old driver photos, and get a sense for how well they’re able to use our proposed filters to find specific rides. In the concept tests, we had actual Lyft riders go through tasks like looking up all of your bike rides in a given month or finding a business ride you took in February of last year, which were all aimed at seeing if they’d utilize our new features to accomplish the tasks.</p><figure><img alt="Designs for second round of concept testing" src="https://cdn-images-1.medium.com/max/1024/1*o67BgZywxRYiIYEOhd5kdw.png" /></figure><p><strong>All riders understood what the connector lines represented</strong>, as they were able to correctly identify which offerings were charged together and which weren’t. All riders found the filters to be intuitive and useful, with some proposing to <strong>rename the “Time” filter to “Date”</strong> since they initially assumed that time literally meant the <em>time of day</em>, for which they weren’t entirely sure if a filter was necessary. There was no desire from riders for a multi-select option in the “Type” filter, validating our initial assumption that there wasn’t a strong use case to warrant it in the first place. Most of the riders didn’t seem to mind that driver photos were replaced with icons of the transportation mode, with some asking if they could still see the photos in the detail view (which they could) to ensure accuracy.</p><figure><img alt="Final Lyft History designs (light mode and dark mode)" src="https://cdn-images-1.medium.com/max/1024/1*26MPoADOJxm3mPRUqg5T9w.png" /></figure><p>The destinations visible in the History view also received positive feedback, with <strong>riders appreciating the extra level of detail now available in the view. Some were rightfully confused as to whether this was a pickup or drop-off address, especially because the time we show next to it is the pickup time.</strong> We addressed this after the sessions by adding a “to” in between the pickup time and the drop-off address so that it now read as “9:06 AM to 250 Geary Blvd,” eliminating any ambiguity about pickup or drop-off times and addresses.</p><figure><img alt="Final Lyft History designs (filters applied and empty state)" src="https://cdn-images-1.medium.com/max/1024/1*dx9jzzAd278B_CMV8JgoeA.png" /></figure><p>Finally, I worked with our LPL design systems team to streamline the visual styling of the filter buttons. We updated the contrast in the selected state to comply with A11Y accessibility guidelines and created a component system where filter buttons could be used with or without a menu-style option that popped up a quick-select menu on tap. Filter buttons could also be used with or without icons. This redesign was one of the foundational projects that kickstarted the need for filtering across all of Lyft’s offerings.</p><p>After making the minor design updates, I presented the final designs a second time to our Design Leadership Team and we also shared the work with our VPs and Directors on our immediate teams. Everyone was on board with the new direction and appreciated our user-centricity and tight collaboration between design and research throughout the process. Overall, <strong>it took about six months from beginning to end</strong> exploring, refining, iterating, and testing the designs with users while also frequently sharing and communicating progress internally. I’m pretty happy with how it turned out.</p><p><strong>Disclaimer: </strong>As of Dec 2022, this view is <em>not</em> live in the Lyft production app. You’ll probably still see the old Ride History view in your Lyft app. This milestone of the project got deprioritized due to changing company initiatives, so these designs never quite made it into the implementation phase. More on this at the end of the post!</p><h3><strong>Part III: Sweating the details</strong></h3><p>That wasn’t all, though. Throughout this process, I was also simultaneously working on the <strong>Ride Details view</strong>, which is accessed by tapping into a ride from the main History view. This screen had an entirely different set of problems, so I’m diving into it in a separate section.</p><figure><img alt="Current Ride Details views for Rides, Bike rides, and Rentals" src="https://cdn-images-1.medium.com/max/1024/1*oYbGzIolO08eX_ocHgvMbg.png" /></figure><p>Once users had found a specific ride from the main History view, we needed to present the most relevant and actionable information about the ride. Our Ride Details view hadn’t ever changed from the first version that was shipped years ago, so this was a great opportunity to <strong>significantly overhaul the experience to better cater to rider needs.</strong></p><figure><img alt="Information architecture rework exploration for Ride Details" src="https://cdn-images-1.medium.com/max/1024/1*9s9JGrKpLsuV3YHNuLoxEA.png" /></figure><p>The first thing I did was take a pass at the order and presentation of information in this view. Are we showing the most relevant stuff that riders need to see here? How much are we making them scroll to get to the important things? I <strong>blocked off different sections of the screen into “modules” that we could re-order as needed based on the type of offering</strong>. We were also planning to use these in research sessions and have riders order the modules themselves based on what they felt was most important in a participatory design exercise.</p><figure><img alt="Early explorations for restructuring the IA in the Ride Details view" src="https://cdn-images-1.medium.com/max/1024/1*IlWcIGDCwcGrFO8BM7g56g.png" /></figure><p>Something that we constantly heard from internal stakeholders about the Ride Details view is that <strong>access to help felt “buried” at the bottom of the screen</strong>. So naturally, some of my early explorations involved making the help CTA more prominent and placing it higher up on the screen, along with restructuring the view to better display relevant information about the ride in a logical hierarchy. I experimented with various layouts to see if it access to help would start to feel less “buried” or not. A big question on my mind throughout these early explorations was relevancy: what are the top things that riders care about and need to see here, and how should we best present that information? We decided to dig really deep into these during our research sessions.</p><figure><img alt="More early explorations for scaling the new IA to other Lyft offerings" src="https://cdn-images-1.medium.com/max/1024/1*vsmXQqeKZPYsniAaC1IxlQ.png" /></figure><p>The module-based approach of structuring related content into their own section of the view seemed to work really well. The “ride” module scaled neatly from Lyft rides to bike rides to rentals, and the rest of the view was able to evolve according to the needs of every individual offering, so I kept pushing this idea forth. I still had doubts and unanswered questions about the placement and ordering of the modules as well as the prominence of support, but these were all to be answered in concept testing.</p><figure><img alt="Explorations for adding co-rider feedback and information in shared rides" src="https://cdn-images-1.medium.com/max/1024/1*Ljh2RNt9QH06P_-vvtr75g.png" /></figure><p>Another important factor in the design principles was to <strong>ensure that we’d be able to scale this view to handle shared rides.</strong> We wanted to start displaying co-riders that may have been in the ride with you in order to enable safety reporting in addition to displaying co-rider pickups and drop-offs on the map. Due to privacy concerns, we <strong>eliminated displaying exact pickups and drop-offs on the map</strong>, but we continued to show co-rider photos and first names in the Ride Details view to ensure that any safety incident could be accurately reported from the Ride Details view. I experimented with a dynamic reporting flow but eventually scrapped it for a version that pushes uses further into a dedicated reporting flow that can capture the incident details in a more comprehensive manner.</p><figure><img alt="Explorations for displaying educational modules in Ride Details" src="https://cdn-images-1.medium.com/max/1024/1*FjFjclu8_z-rg1CvBwWV9Q.png" /></figure><p>Finally, we were sensing a lot of desire from other internal teams to <strong>use Ride History as an educational surface</strong>, so I also explored some ways to display informational banners in the relevant offering, showcasing how the view could scale over time to include this. Lyft rides could display other ride modes that the riders don’t frequently use, while bike rides could proactively mitigate riders being surprised by high fees. Having the ability to display these in Ride Details reassured our cross-company partners that this redesign has a lot of potential for rider education.</p><h4>Refined iteration</h4><p>In our first round of research sessions, we did a participatory design exercise where we asked riders to order the modules based on the information that they’d like to see. <strong>Eight out of ten participants had the exact same ordering, with the Trip information at the top, followed by Payment, Ride, and Help.</strong> Most of them called out that they’re used to seeing help links at the bottom of the view in other products, adding that it’s helpful to go through the other modules and verify the information first before deciding to contact help. As a result, I re-designed the view to match their expectations.</p><figure><img alt="Final Ride Details views for rides, bike rides, and scooter rides" src="https://cdn-images-1.medium.com/max/1024/1*5di10sJHES4PU1-eD7iaRg.png" /></figure><figure><img alt="Final Ride Details views for rentals, vehicle service, and self-driving rides" src="https://cdn-images-1.medium.com/max/1024/1*wom_L5flnmymq3YSrY6eTA.png" /></figure><p>I also <strong>extended our platform approach to the Ride Details view</strong>, ensuring that this <strong>module-based framework scales to all of Lyft’s current offerings</strong> including rentals, bikes, scooters, self-driving rides, and vehicle service visits. Transactions like Lyft Pink membership fees and Lyft Cash purchases didn’t have a dedicated “detail” view and would instead link out to different sections of the app, so we left that out of the designs. We also heard a desire for riders to want to be able to resend a ride receipt to themselves (which previously required reaching out to a support agent), so we included a way to do this in the new designs.</p><figure><img alt="Ride Details: Additional states for Payment and Help modules" src="https://cdn-images-1.medium.com/max/1024/1*XjdY4_NP2Sp7ptfv07U-IQ.png" /></figure><p>In response to user feedback, I also added several variations of modules to handle support outcomes.<strong> Automated resolutions and assisted support contacts would now display in the view</strong>, with fare-related outcomes showing in the Payments module and other support-related outcomes displaying in the Help module. The <strong>Ride Details view now dynamically evolved with the post-ride support outcomes</strong> instead of just keeping the static receipt-like layout that it formerly had. Overall, the addition of all these features means that riders will be able to <strong>self-serve and self-resolve their most common issues or points of confusion </strong>instead of needing to get in touch with a Lyft support agent. Tracking this decrease in support outreaches was one of our success metrics for this project.</p><figure><img alt="Before and after of the Ride Details view" src="https://cdn-images-1.medium.com/max/1024/1*piUJFpuiwmgQBC5aWCEi8w.png" /></figure><p>There are many, many micro-variations of every module here, changing states to handle uncommon scenarios like stops during trips, multiple payment methods, banners and callouts for certain situations that can happen during a ride, and time-based triggers like changing payment methods or tipping that disable and update the UI after some predetermined amount of time. As with the former designs, we extensively reviewed these with all internal teams at Lyft to ensure that it was a scalable solution that we could build new offerings on and got the necessary approvals to finalize and build out the design.</p><h3><strong>Scaling Lyft History</strong></h3><p>We broke out the projects into milestones, starting with the Ride Details view and then the Lyft History view. The redesigned Ride Details view made it into the app and is currently live on both iOS and Android (as of Dec 2022). The redesigned Lyft History view did <em>not</em> make it into the app due to changing company priorities. When this project started, Lyft’s priority was to evolve Ride History and scale it to incorporate all of its multi-modal offerings. Six months into the project, the company priorities had pivoted to solving the pressing driver supply concerns. Something had to give, and this was one of the projects on our team that got shelved, unfortunately. We completed the design phase, but the project didn’t make the cut to get into implementation.</p><figure><img alt="Before and after of the Ride History view" src="https://cdn-images-1.medium.com/max/1024/1*qjjzxudaBRhDrR5LnYYRyQ.png" /></figure><p>Compared to what it looked like before, the History view is far more visually streamlined. Arguably, it feels less “human” than it did before since we don’t display driver profile pictures anymore, but at the same time, the feedback we were getting from riders was that the <strong>pictures weren’t exactly useful in recalling the ride</strong>. Riders used information like date, time, and destination to recall past rides. More importantly, <strong>the view now scaled to handle all of Lyft’s current offerings</strong> elegantly while also clarifying how our Daily Billing mechanism works.</p><figure><img alt="Final mocks of the redesigned Lyft History and Ride Details" src="https://cdn-images-1.medium.com/max/1024/1*2Bs3ta-pwxt_1WtoiKDGEw.png" /></figure><p>I’d like to give a special shout-out to everyone at Lyft involved in this project, without whom it wouldn’t have been possible: Carolyn Buehler, Aneri Chouhan, Elyse Hovanesian, Nicole Pearce, Ella Werthan, Ernesto Lucar, Bomee Park, Jeffrey Chen, Igor Fedulov, Nico Magana, Jiaqi Wang, AnnaMarie Garlin, Chuanxin Hu, David Wu, Gagan Singh, Elizabeth Hamp, Nick Creegan, Stephanie Carpenter, Gemma Morgan, Guillermo Torres, Brian Ng, Rafae Aziz, Jen Williams, Johan Jessen, Megan Ellis, Nayeon Kim, Kari Bergstedt, Cooper Smith, Sravanthi Kadali, Eunice Joung, Eric Burdullis, Ashwin Raj, Audrey Liu, Kevin Kwong, Amanda Schwartz, Conor Buckley, Runi Goswami, Michael Yom, Jeremy Dizon, Linzi Berry, Alex Lockwood, Alina Yehorova, and Ievgenii Pogosian.</p><p>Despite the fact that the main Lyft History view did not ship, I’m still really proud of the work we did and how it turned out. In today’s tech landscape, it’s become really common for companies to scrap ongoing initiatives and take on the more pressing challenges instead, which inevitably causes a lot of thrash for designers who have been working on a problem for months or even years. Nevertheless, the designs for this project are ready to go, whenever this initiative becomes a priority for Lyft again. It might require yet another redesign if regulations or Lyft’s offerings have significantly evolved by then, but oh well, you can only control so much as a designer. I’m still happy with the design work I did and how the final design turned out, regardless of whether or not it makes it into the Lyft app.</p><p>I hope this has been insightful and has shed some light on the design process for a project of this size and scope; please feel free to reach out if you have any questions about any of it. Happy to answer them! Cheers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d3d4cb41291" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Book cover illustrations: The design process]]></title>
            <link>https://medium.com/@a_kill_/book-cover-illustrations-the-design-process-eb5995c87b90?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb5995c87b90</guid>
            <category><![CDATA[book-covers]]></category>
            <category><![CDATA[illustration]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[case-study]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Wed, 24 Nov 2021 05:48:41 GMT</pubDate>
            <atom:updated>2021-11-24T06:56:35.146Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hSUgU96SUK21AnVfp6Mm0g.jpeg" /></figure><blockquote>“A book cover is a distillation, a haiku, if you will, of the story.”</blockquote><p>Famed book cover designer <a href="http://chipkidd.com/home/portfolio-3/">Chip Kidd</a> is credit with the quote above, while referencing a series of covers he did for <a href="https://tezukainenglish.com/wp/?page_id=531">Osamu Tzuka’s <em>Buddha</em></a>, where the spines of the books visually tell the tale of the chronology as the collection unassumingly rests on a plain bookshelf. I’ve always been a fan of Kidd’s work, and it is perhaps this alluring temptation to somehow capture the essence of thousands of words in a visual snapshot, with some added creative twist, that inspired me to try designing book covers for myself.</p><p>I was already itching to expand my design work beyond digital interfaces when <a href="https://getoutofyourhead.com/about/">Brian Sachetta</a>, a good friend and former colleague, reached out asking if I’d be willing to design a cover for a book that he was working on. I jumped at the opportunity to take on this project. Several months of collaboration later, we had a striking cover that fit the tone and message of his excellent book. Our partnership carried on to a second book as Brian started to establish himself as an author in the genre, and I had the honor of working on the cover for the second book as well, which came out even more stunning.</p><p>This post details the design process for the both the books, diving into how we landed on the concepts and the challenges we faced along the way. As with any design process, there’s a lot of doubt, uncertainty, excitement, elation, and satisfaction. The process for designing the covers for both books was quite different, so I hope this serves as a useful reference for anyone looking to get some insight into what goes into designing a book cover.</p><h3>Book One: Getting out of our heads</h3><p>First, some context. Brian, the author of the books, has had many personal experiences dealing with anxiety and depression, and he managed to overcome these mental health issues through a combination of practical self-developed strategies backed up by a lot of scientific research. He decided to share his learnings with the world, through the most accessible medium available to all, books.</p><p>When Brian initially reached out to me, there was no creative brief or design spec to follow. This was his first book and he was open to anything. I was to come up with a concept for what the cover should be, as well as execute it using my design skills. In my head, it wasn’t that different than creating a logo or a feature in a product. The task was the same: to capture the abstract message of the project and convert it into a visually digestible theme.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jg2bQ81OsKto54cD-T1Ksw.png" /><figcaption>Our original moodboard where we collected covers we liked and how they captured the message of the book: simple typography, strong visual metaphors, and striking imagery were common themes.</figcaption></figure><p>All I had to work with at this point was the title “<em>Get Out of your Head</em>” and the subtitle “<em>A toolkit for living with and overcoming anxiety.</em>” The title alludes to the fact that the best way to deal with anxiety is to stop battling it and instead utilize it as a mechanism for survival and growth, and the framework to do this is by stepping outside of your own mind to observe yourself as an outsider. The subtitle goes on to explain that the book offers this framework in the form of a toolkit.</p><h4>Exploring the concepts</h4><p>With any project, starting with a blank page is incredibly intimidating. You have no baseline for what’s good and what’s bad. The best thing to do is to start somewhere, and so I did. Using the moodboard as a reference, I tried out a wide range of themes in different layouts and styles. Visual covers, typographic covers, and graphic covers all trying to capture the thematic essence of progressing from chaos to clarity in the human mind. For me, capturing all the ideas in my head out onto the canvas is the best way to eliminate the bad ideas and start to focus on the ones that are working.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A6q4MryUmxP8gFRXaYserw.png" /><figcaption>A dump of all my initial explorations; made in grayscale in lo-fi to move quickly. Many of the typographic versions play with kerning, line height, and warping to convey moving from “tightness” to “lightness” (in the mind), while the ones with imagery try to illustrate a “trapped” mind or brain.</figcaption></figure><p>It’s important to stress here that at this stage, the client has no idea what the cover should be, and neither do I. This is a process of divergent exploration to branch out as far as possible with all the different possibilities in order to then narrow it down into two or three that we like. It’s also crucial to not get too attached to one idea in this exploration process; the goal is to simply diversify and explore as many as possible. There are no rules and the options are limitless, so I just tried out as many options that I could think of.</p><p>For a lot of these explorations, I only put in enough details to convey the concept, nothing more. The ones with the imagery was just me grabbing stock images that I liked and de-saturating, blending, and blurring them as needed to convey the tone and feel. The plan was for the actual image (if we were to go down that route) to be created from scratch as an original illustration. Once I had a good set of varying explorations that I was happy with, I shared them with the author to go over the pros and cons of each style.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NdM_EtTZf_Xwle9S19lZjw.png" /><figcaption>The three concepts we liked the most; the calendar concept (left), the traffic sign concept (middle), and the “brain glove” imagery (right).</figcaption></figure><p>After a spirited discussion about each exploration, we narrowed it down to three concepts. One of them was an idea I had to visually display a calendar. This stemmed from a personal struggle both Brian and I shared with calendar appointments: the anxiety of knowing that we’ve got an upcoming meeting doesn’t let our minds rest. We fret nervously and our brains constantly go into worst-case-scenario mode of all the things that could go wrong in the meeting. But when the meeting actually happens, we’re totally fine and realize that there was nothing to worry about all along. The visual tries to capture the mental anxiety of this feeling leading up to the meeting by displaying calendar blocks visually in a typical work week, with the book title tightly sandwiched in-between.</p><p>The second concept was based around a traffic sign. The idea here was to leverage the recognizability of a typical yield sign in order to grab the viewer’s attention as they browse a busy bookshelf and get them curious about it. It works well as a direct instruction to the viewer about what the message of the book is and conveys an expectation that there will be a recommendation provided in this book, an important distinction to make in an otherwise crowded genre of self-help and mental health books.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S2quVoCu1cyBZiUoyYx2zQ.jpeg" /><figcaption>The concept that we decided to pursue — the “brain glove.”</figcaption></figure><p>The imagery we ended up choosing was the one that we thought would have the strongest impact, the “brain glove.” The image in the lo-fi mockup was actually a part of <a href="https://wheresmyjetpack.blogspot.com/2010/02/if-i-only-had-brain.html">an advertising campaign for a hospital</a> to bring awareness to the devastating effects of a stroke. When I was talking to Brian, he pointed out how strongly the imagery resembled his book’s message of a “battle” against anxiety. There is a constant desire to “fight” anxiety when you have it, and the boxing glove is a direct allusion to that. The fact that the boxing glove is cerebriform, i.e., brain-like in the form of a convoluted, fleshy, and irregular mass of lesions and folds, created a striking contrast and merged the two concepts of a “fight” and the “mind” in one powerful image.</p><p>And that was it. Amongst all the various paths we could’ve gone down based on the original explorations, we chose this one and stuck to it all the way to the finish line. Sometimes, it’s this easy to choose one option amongst the many because the choice feels so obvious. Other times, this exploration phase might require two or three rounds to land on a concept that accurately captures the book’s message. We were able to quickly pick out the good idea that worked without wasting too much time on the ones that didn’t.</p><h4>Nailing the execution</h4><p>Now that we knew what the imagery on the book cover would be, it was time to move on to the execution phase and figure how to best display it visually on the cover. Would it be a photorealistic mockup of a brain glove or an artful rendition of the concept? What orientation should it be displayed in? Should we have one glove or two? How does it interact with the book title and subtitle, if at all? How large should the image be proportional to the text? These are the questions I was looking to tackle and answer here.</p><p>And again, the best way to start answering these questions is to just start getting answers to them. We can spend days or weeks debating the pros and cons of each approach, but hacking together quick mockups at a medium fidelity level would provide faster answers than any back and forth discussion. So I started down the path of trying out if a photorealistic image of a cerebriform boxing glove held any water to merit further design refinement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Is6wKDyHjCo0p8mA-EB2DA.png" /><figcaption>A very rough mask-and-blend job in Photoshop on stock images of boxing gloves and brains was enough for us to get a feel for what a photorealistic rendition of our imagery would look like on the cover, and we weren’t really big fans of it.</figcaption></figure><p>As soon as I put together a rough mockup of the photorealistic version, we both knew this wasn’t it. It was so realistic that it gave us uncomfortable uncanny valley vibes, and it just looked gross. It’s always a good exercise to put ourselves in the shoes of someone experiencing anxiety as they browse through the self-help and personal development section of a bookstore. Seeing this on a book cover is <em>not </em>something that would compel them to pick it up and check it out. In fact, it might have the exact opposite effect. So we scrapped the photorealistic mockup idea.</p><p>This exploration did, however, give us some good insight into the composition. We liked that the gloves were “hung up” as a pair. The book constantly refers to the idea of “giving up the fight” against anxiety, which directly alludes to the imagery of “hanging up the gloves” after a match. We liked the idea of a hanging boxing glove for this reason, and tried to preserve it as an option going forward while we tried out an illustrated version of the cerebriform boxing glove.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pwgjYE65eT-rwTW6P6VEAQ.png" /><figcaption>The very first illustration of the brain glove I created (left), with a mockup of a “hanging glove” in the middle with some stylized typography (middle), and a cover mockup with simplified text styling (right).</figcaption></figure><p>So I finally sat down and spent some time creating an illustrated version of the cerebriform boxing glove. Using the original image as a reference, I used some basic flat highlighting and shading to give it a style and flavor of its own. Once that was done, I mocked it up as a “hanging glove” on the book cover, trying out some variations on the typography.</p><p>One big learning right off the bat was that it would be too busy of an illustration to have two illustrated “brain gloves” hanging next to each other on the cover. The detailing in the lesions and folds are so organic and convoluted that it just gets very noisy, visually speaking. We might even lose the separation of where one glove ends and the other begins if we were to put two right next to each other, so we just kept it to one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LA9eoyM4aqQrD-QagCMlrQ.png" /><figcaption>Vertical orientation (left) vs. the horizontal orientation (right); as I kept refining the designs to nail the correct orientation and sizing, I also kept tweaking the type styling and contrast in parallel.</figcaption></figure><p>A big decision we made around this stage was to lose the vertical “hanging glove” orientation and instead go with the horizontal “resting glove” orientation. We felt that this was less in-your-face and easier on the eyes. The problem with the vertical version was that it was too large and ambiguously cropped to quickly process that it was a “brain glove”, whereas the effect worked immediately on the horizontal version with the entire thing in frame.</p><p>At this point, the most pressing feedback from the author was that the brain glove looked too “demonic,” to use his words directly. For a book about mental health, it sure seemed incredibly intimidating to pick up and peruse from a bookshelf. I agreed with this feedback. It definitely had a scary vibe, but I wasn’t entirely sure how to go about making it look more friendly and approachable. What follows is a series of attempts of me trying to figure out how to make it less demonic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r9VEElvJJ8jyg_fghcsXgQ.png" /><figcaption>Various attempts at re-coloring the brain glove to see if any of them make it feel less demonic (they didn’t).</figcaption></figure><p>One of my first attempts was to try re-coloring the brain glove with a different color palette. I figured it could be the color that was making it look too scary. So why not start there and change that to see how it feels? I distinctly remember thinking something along the lines of “well the brain is technically gray and full of gray matter, so why not try a gray version?” and “there’s no way it can look scary when it’s pink, pink is such a friendly color.”</p><p>But alas, the brain glove still looked too demonic in all the color variations. The author still felt that something needed to change beyond just the color of the brain glove. I’ll confess something: I was trying to avoid not having to re-do the entire illustration and just solve the problem through minor adjustments like tweaking the color palette. But clearly, that wasn’t working. I knew this needed a larger redesign, so I opened up Illustrator and got to work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vrdcgJI2WEoNELV8fOi-ww.png" /><figcaption>Various alterations to the original “demonic” brain glove (top-left) eventually led to a version of the brain glove that feels unthreatening (bottom-right).</figcaption></figure><p>This just required lots of detailed tweaking and fine-tuning. I went into every little fold and lesion and modified the curves to be less sharp and a lot thinner. There’s a lot of neuroscience and research done about sharp visual shapes that convey threatening undertones, so simplifying and rounding off the black sections helped immensely in making it seem more approachable.</p><p>I also reduced the deep blacks and gave it a more flesh-y color in the final version, with the darkest areas lightened up to be more of a deep shadow instead of a full black. This part of the process took a lot of time, with me working on it on-and-off as I found time to keep refining this brain glove. After many rounds of revision, the author agreed that it had finally gotten to a good place and that we could call it final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h8NnWuDLwF9SlYCFbEzwyA.jpeg" /><figcaption>The final spread with the front cover, spine, and back cover.</figcaption></figure><p>There was one last thing to take care of — the back cover. We actually decided that the dual “hanging gloves” motif could be repurposed for a small illustration on the back cover to accompany the “Give up the fight” tagline. The lockup worked really well with the strong correlation between the messaging the the visual metaphor. Using both gloves here worked better than we expected, without any loss of visual clarity on the part where both gloves overlap each other. I added some minor cast shadows to distinguish the gloves where the make contact with each other.</p><p>The author had a text blurb for the back cover that I made room for and dropped the copy in. I also created a footer section to hold the ISBN code and any footnotes that may be required. For both the front and back covers, I used the basic 5 x 8 sizing that’s commonplace for all e-books, as the author had indicated that he primarily intended to self-publish the book on Amazon first and then run a few limited prints of paperback copies. Thankfully, the simple and straightforward layout of the design elements allowed for quick and easy resizing for a variety of cover sizes, so that made the job simple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ri7JXKGWfVDt6cCcnDVq6g.jpeg" /><figcaption>The final front and back covers, available now (but with a different cover)!</figcaption></figure><p>The book ran with this cover for two years, from launch in December 2018 to December 2020. After that, the author wanted to establish a new identity for the Get Out of Your Head brand, as he planned to make this into a series of books about mental health. The updated brand identity was applied to the first book’s cover in January 2021, and the book is currently <a href="https://www.amazon.com/Get-Out-Your-Head-Overcoming/dp/1732932611/">available for purchase on Amazon</a> (with the new cover).</p><p>It was a blast to work with Brian on his debut as an author and I couldn’t be more pleased with the outcome. The original cover was replaced as part of the branding update (or should we say…it has gone <em>vintage</em>), but it served its purpose really well in the time the book ran with it. The strong visual metaphor of a cerebriform boxing glove paired really well with the message of the book and stood out as a striking visual image in a sea of self-help books that all seemed to have some version of an unmemorable abstract or typographic cover on them. It got people to pick up the book off a shelf and get intrigued by it enough to explore it further, which is exactly what it needs to do. Design process aside, I can also highly recommend giving the book a read for anyone struggling with anxiety who’s looking for some practical tips on how to live with it.</p><p>Overall, I loved the process of working with the author to come up with a concept that best represented the theme of his work, and then execute that concept through detailed design refinement. I wouldn’t call myself an expert illustrator, but I’m quite satisfied with how the simplistic and straightforward delivery of the illustration works in favor of the book’s message. Little did I know that I was counting myself lucky here, because it wasn’t long before I got the chance to work with Brian again on his second book, and the illustration for that cover didn’t quite turn out to be so simple.</p><h3>Book Two: Navigating the abyss</h3><p>A few months after the launch of his first book, Brian approached me again to chat about working on the cover for his second book. Now that he had written about anxiety, he also had a lot to share about his experience with depression. I had a great experience learning about the design of book covers the first time around working with him, and wanted to kick it up to the next level with something a little crazier this time. So naturally, I said yes.</p><p>This book was about depression, and Brian had warned me ahead of time that working on this might put me in a dark headspace. The subject matter was incredibly grim and dark, and he felt like it may not be as fun of an experience to work on as the first one. Nevertheless, I felt ready for the challenge and signed on for another rollercoaster of an adventure working on book covers.</p><h4>The drawing board</h4><p>The process was different this time around right from the beginning. For starters, Brian didn’t need any conceptual exploration for this book. He already had an idea in mind that he thought would work really well. He likened depression to the Nitezsche quote that goes “<em>And if you gaze long into an abyss, the abyss also gazes into you.</em>” The idea was that the longer you spend being depressed, the easier it is for your brain to fall into a spiral of progressively darker and darker thoughts, making it even more difficult to escape. This was the visual metaphor we wanted to capture on the cover.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hP4qFoKbGACAopLUzD85vA.jpeg" /><figcaption>The original moodboard that the author had put together to capture the tone and vibe of this second book.</figcaption></figure><p>Our moodboard this time around reflected this dark and grim imagery of gazing into some kind of “abyss” and various allusions to a mind “spiraling” out of control as it goes deeper into this abyss. My challenge was to portray this sentiment without getting too caught up in the “darkness” mood of the subject matter, because after all, this is again a self-help book cover that needed to be approachable on a bookshelf.</p><p>Brian had penned down “<em>Navigating the abyss</em>” for the title this time around and “<em>An escape rope from the bottomless pit of depression</em>” for the subtitle. This title and this moodboard is all I had to start with. I could already see some ideas starting to form in my head of how to capture this idea of a spiral and an abyss in one captivating image, so I got to work putting together some lo-fi grayscale mockups with the title and subtitle that I had to work with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*idAnR_dMvg5Z-uXvFrhUIQ.jpeg" /><figcaption>My initial explorations for the thematic execution for this book, with various takes on the imagery for an “abyss/spiral” shown in the first three and a couple of unconventional visual metaphors on the last two; I was also experimenting with type pairings and layouts across all the explorations.</figcaption></figure><p>These were quite fun to put together. I first had a basic version of an “abyss” that was a modified image of a black hole. I then had one that was a circular maze with a hypnotic spiral on its outskirts, representing how the book can help the reader navigate the maze of this abyss by giving them a way out. I had one that was an extremely zoomed in version of an iris, literally playing on the motif of “gazing” directly into the abyss (the reader) and having their reflection gaze back onto them. And then I wanted to try a couple of unconventional ones: a purely typographic cover with the text on the edges of a bottomless pit and one where a human figure is gazing downward off the steep edge of a cliff (which we scrapped due to the suicidal imagery).</p><p>When I reviewed these with the author, he seemed to think that all of them could work well. He felt that we should keep pushing on the basic “abyss” theme and keep refining that exploration further. In addition, he mentioned that he had gotten pretty far in working on the book’s first manuscript and noticed that he was using nautical terminology that he referenced quite often throughout the book. So he suggested that I try tying in the abyss to some kind of seascape with a boat, perhaps one that’s trying to navigate a maelstrom that was in its path up ahead.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2cRnInFLIY6jv_odD_i5Bw.jpeg" /><figcaption>My initial exploration for incorporating some nautical imagery, with a sample mockup on the bottom-right</figcaption></figure><p>I tried out a symmetrical layout where a sailor (or captain) is standing at the bow of the ship in a stormy sea looking ahead at a maelstrom that’s in the path. The idea with the composition and framing was to put the viewer at the reference angle and scale of a human that’s powerless against the forces of nature, drawing parallels to the helplessness one feels against depression. The malestrom was to be this mystical and seductive presence that dominated the background of the cover, beckoning you to gaze into it.</p><p>This quick mockup was hacked together using stock images and some rough outlines to get a sense of the layout and composition. At this point, we had no idea what the artistic styling of the cover would be, but using stock images and photos to blend the elements usually gives a solid indication of whether or not the concept works. I also tried blending the title into the maelstrom, almost as if everything is getting sucked into this all-encompassing abyss. Reviewing this with the author led us to the decision that we should <em>definitely </em>pivot to a nautical theme for the cover and do more explorations around a more specific theme, one that the author already had in mind.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q9oZITEVbm5_tPKjOVYE3g.jpeg" /><figcaption>A sketch that Brian sent me (top-left) along with a few visual references led me to loosely translate the ideas into a rough sketch of my own (bottom-middle) along with a rough blockout to get a sense of the layout and composition (bottom-right)</figcaption></figure><p>Brian was drawn to the idea of a sailboat navigating a storm, which is what experiencing depression oftentimes feels like. You’re hopelessly sailing towards disaster while everything falls into chaos around you and you can’t do much about it. This is why he felt that the imagery would be a strong fit for the cover. He explained that the visuals of tattered sails, a large sailboat that looks like it has taken a serious beating, and a large swirling storm somewhere in the distance would be extremely fitting for the tone of the book and would fit the nautical analogies he often used really well.</p><p>My most immediate concern here was that this could end up being a really busy cover. We had a lot of clarity on the cover of the first book, and we were suddenly pivoting to a cover with a lot happening on it. I was wondering if the message would come across as clearly as we would want it to. Furthermore, I was also intimidated by the prospect of having to illustrate a boat, an ocean, and a storm. I had no idea how to make an illustration as complex as this. The author also had some reservations about whether or not this would work, because the concept screams more “pirate adventure novel” rather than “mental health book about depression.” As always, the only way to move forward was to mock something up and get some feedback on it.</p><h4>Setting sail on execution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fLTqZv38qMl1Ttz5yUMMhg.jpeg" /><figcaption>Visual style references for illustrating the boat (most are from Dribbble).</figcaption></figure><p>So I set out to capture some visual references of how to illustrate a boat. My process here typically involves looking up the work of others on Dribbble, Deviantart, or Behance to try and get a sense of what would work and what wouldn’t. There’s a million different ways to draw a boat, and the client will have no idea what they want until you make something and show it to them. I was also experiencing a good bit of imposter syndrome here, feeling like I had taken on a complex illustration project that I felt like I couldn’t deliver on. I personally knew at least a dozen designers who could illustrate better than me, so I knew that this would be a bit of a struggle for me with a lot of trial-and-error involved in the process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*586m2dDeZsN_iRL4MqR9qg.jpeg" /><figcaption>My first illustration attempt of the boat and ocean.</figcaption></figure><p>Using the visual styles as a reference, I drew a simple boat. I then tattered the sails to give it a bit of a damaged look and put it in context of an ocean. I was trying to go for a simplistic look with clean lines that was easy to visually process with a quick glance. It needed to be immediately obvious that this was a boat in an ocean; I feared that it would get too complex if we started to add too much detailing in the ocean and boat. I was also experimenting with the scale of the boat to make it significantly smaller in proportion to the ocean, emphasizing the effect of hopelessness that the cover was trying to convey.</p><p>The feedback from the author on this cover was that it completely missed the mark of what he was envisioning. For starters, he wanted a <em>large</em> sailboat; a massive sailing ship with multiple sets of sails, like a Galleon or a pirate ship. He was also not a big fan of the simplistic ocean. The vibe of the cover needed to be stormy and chaotic, something that the calm mood of this ocean does not portray. Overall, this cover was too simple, too small, and too calm. This kind of feedback is crucial to get because had I not created this mockup, I would have never known any of this. I now knew what kind of ship to make, what the ocean needed to do, and what the tone of the whole cover should be.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZaKdoxzjRogtgPN5U5I9PQ.jpeg" /><figcaption>Visual references for large sailboats.</figcaption></figure><p>And then came another round of capturing visual references for ships, this time more specific: art and paintings of large Spanish Galleons from the 16th to 18th century. I was looking for patterns and commonalities between all these. The sails seemed to dominate the silhouette of the ship, exaggerating the size of the ship. I also went too deep down a rabbit hole learning about the design and structure of these ships to figure out what parts were essential and which ones were purely decorative, mostly as an attempt to figure out where I could take some creative liberties in the illustration.</p><p>It was at this stage that it dawned on me how different the design process for this cover was compared to that of the first book. With the first cover, we simply picked a concept, made some quick decisions on the orientation, and then spent the rest of the time refining the illustration. Here, we switched the concept early-on and were frequently going back and forth on the basic elements of the cover. It just goes to show how drastically different the design process can be depending on the needs of the project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*teuu4r7Mp4IDlkMg_Ti1gg.jpeg" /><figcaption>Creating a medium-fidelity version of the ship (in grayscale) to get a feel for the perspective and relative proportions of the boat; I overdid the tattered sails early on and then reduced it based on the author’s feedback. Early mockup of what it could look like on the cover in a stormy ocean (stock image) on the far right.</figcaption></figure><p>This time around, I made sure to create a larger ship (still in grayscale) and nail the perspective and proportions. I had two sets of sails with a lot of tatters on all of them. It ended up being overkill, so I reduced it and mocked it up on a desaturated stock image of a stormy ocean. Again, I had no idea how to illustrate the ocean at this point, so I was using as many workarounds to avoid illustrating it but was still trying to convey the feel of it somehow through these medium-fidelity grayscale mockups.</p><p>The author’s feedback here was that this is more the direction he was thinking of. This sizing, angle, and direction that the ship was facing felt a lot better here. He also suggested that we maybe try a centered composition with the maelstrom below the ship (directly underneath) and make that the focal point of the whole composition. He had another new idea to leverage here, which was to leverage the symbolism of a “spiral” to visually convey that a storm was brewing below the ship trying to suck it in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GVhRErhq--myWi_2JEvJdg.jpeg" /><figcaption>The imagery of a “spiral of depression,” a concept that we could visually showcase by combining it with the imagery of a maelstrom or a whirlpool sucking the ship in underneath it</figcaption></figure><p>In the book, Brian alludes to the idea of depressive spirals often. The concept is that once you start sliding downwards into the spiral, it’s easier to get sucked deeper and deeper into it. Going back to the original Nietzsche quote of the abyss gazing back into you the deeper you gaze into it, the spiral sucks you in further the deeper you let yourself fall into it through its self-perpetuating cycle of depressive thoughts. If we combined this imagery with that of the storm below the ship (sort of like a whirlpool), we could have a powerful and visually striking composition on our hands. This spiral would essentially become the new “abyss” on the cover.</p><p>The author also mentioned that he wanted to keep the “<em>Get Out of your Head</em>” branding as the title of the book again and have the subtitle be “<em>Vol II: Navigating the abyss of depression.” </em>Essentially, the branding of the first book would carry over to the second one as well. This meant that “<em>Get Out of your Head</em>” would stay as the main title and the subtitle would change to this new one. This had me a little concerned about the available real estate on the front cover with all the new ideas and the moving pieces, so I wanted to lock the composition and get an idea of the relative sizing of all the elements before moving any further with the illustration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TZMbvGSiuUIBUg5NhcLHJg.jpeg" /><figcaption>The rough wireframe-y composition lock for the full spread, including the spine and back cover.</figcaption></figure><p>The new title and subtitle change also came with an additional design constraint, which was to maintain the brand identity and positioning of the elements as closely as we could to the first cover. This meant that the styling and placement of the title, subtitle, and author name had be more or less the same as it was in the first cover in order to clearly identify both books as being part of a series. Brian wanted to keep his options open to turn the “<em>Get Out of your Head</em>” name into a series of books, where he would tackle different aspects of mental health in each entry.</p><p>We quickly decided that the back cover should have some simplistic illustration, like a lighthouse on a cliff. Some kind of imagery that symbolizes a beacon of hope in a stormy sea would do the job, and we felt that a lighthouse would work really well. I also had the idea of carrying over the ocean into the back cover through the spine and have a full-bleed ocean across the entire spread. I already know it would be a nightmare to illustrate (something that I still needed to figure out how to actually do).</p><h4>Cruising into high fidelity</h4><p>Now that we had the composition locked down, it was time to start creating the final illustrations for the ship, the ocean, and the “abyss” (the spiral). I wanted to start in the place where I was most confident—the ship.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TqA-UmeDo6-5NVqe5R5n9Q.jpeg" /><figcaption>A second set of perspective-accurate and proportionally correct visual references for sailboats.</figcaption></figure><p>And so I gathered more visual references for the high-fidelity illustration. Large galleons sailing towards the viewer at a three-quarters perspective with multiple sets of sails. As I understood how the ship needed to be illustrated better, I kept updating my visual reference set with more accurate images, gathering all kinds of concept art from games like <em>Sea of Thieves</em> and diving deep into sub-niches of Deviantart that host dedicated galleries for canvas-sized prints of haunted ghost ships.</p><p>The design process for anything involves frequently referencing some visual target to get an idea of how close or far away you are from it. If I had just started illustrating the ship without these references, I’d have no idea when I was done. I could just stop at any point and claim that it looks good enough. Establishing these visual targets helps provide a framework and timeline for the detailing and serves as a benchmark to measure my work against.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwglseGeRjkj0CH7koSbNw.jpeg" /><figcaption>Progress on the first high-fidelity illustration of the ship.</figcaption></figure><p>So I finally spent a few hours deciding on the basic outline of a hull, planned out the proportions, sizing, and placement of the sails, and started the illustration. I added in more detailing, gave the sails some basic tattering, and added detailing with all the ropes and rigging. Throughout this whole process, I was constantly referencing the visual targets I had established to get an idea of how to illustrate the sails, how much of the inner hull to show, and what kind of shading or texturing to add on the sails.</p><p>I also knew that I would need to more or less match the visuals of the first book in art style, so I knew that I’d need to stick with the flat shading of highlights and shadows. The author had mentioned that he wanted the ship to be a large, swashbuckling pirate vessel that was domineering in appearance, with a raised hull and massive sails, so I exaggerated the scale and proportions a bit to give it that “larger than life” effect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3qiPSJZss9veBqzv0a_gzw.jpeg" /><figcaption>The initial attempt at putting the ship in context with an ocean and the abyss spiral.</figcaption></figure><p>I also needed to figure out how this would look with the ocean. Again, I still had no idea how to illustrate the ocean. We now had another problem in that the spiral beneath the ship needed to be semi-visible through the foreground of the ocean, almost like a translucent whirlpool that you could see through the ocean. My first attempt at this came out looking extremely strange. I was trying to give the whirlpool some detailing rather than just have it be swirling lines, and it didn’t quite look right.</p><p>This was the most difficult part of this entire process. I needed the ocean to look good, but no matter how I tried to illustrate it, it looked <em>wrong. </em>One thing I was trying to avoid was to manually needing to illustrate a realistic ocean, i.e., having to hand draw every single wave and splash of the water effects. I was desperately looking for any kind of shortcut that would allow me to hack together a good-looking ocean without spending too much time on it, but wasn’t finding one easily. In the meantime, I got some feedback on the ship from the author.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GU8LjBVktPyS3vhiDJebkg.jpeg" /><figcaption>Tweaking and refining the ship from the initial version (left) to a new hull (middle) to adding more detailing on the hull along with some updates on the sails, rigging, and shading (right); the version on the right ended up being the final version of the ship we used.</figcaption></figure><p>The author’s feedback was that the ship’s hull felt too short in width and had a strange foreshortened perspective, which I saw as well. So I tried out a newer hull (choosing to model it off of a different one from our set of visual targets) without a three-quarters perspective, which gave it more of an elongated look. I also added some more detailing on it to make it look like it was built from separate pieces of wooden paneling.</p><p>On the sails, I straightened the orientation a bit and changed the tatters to be cuts rather than circles. I also broke off much of the ropes and rigging to make it look like the ship has really been through a lot in the storm that it’s navigating. I updated the icy drips on the hull (which I got from the ghost ship references) to actually be inverse cuts in the wood, which conveyed the “damaged ship” effect a lot better. After multiple rounds of edits and revisions, we were happy with the final version of the ship, which meant that it was time to tackle the thing I had been avoiding for so long —the ocean.</p><h4>Illustrating the ocean</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WvYTUyMbh8OxYNohbHlTtA.jpeg" /><figcaption>Visual references I gathered for how to illustrate the ocean.</figcaption></figure><p>And then I embarked on the daunting journey of figuring out how to illustrate the ocean. All the paintings I came across that seemed to embody the tone of the ocean I wanted felt impossible to create as an illustration. It would seemingly take weeks or months to re-create that style digitally in the aesthetic of the ship. I tried finding Photoshop brushes of ocean waves, I tried hand-drawing waves in Procreate to speed up the process, all to no avail.</p><p>I wondered if I could simplify the perspective of the ocean so that the viewer is only looking directly at it from water level, which would also allow me to then illustrate the abyss spiral directly below it. If I could portray the white foams and waves with simplified abstract brushstrokes (similar to the blue-and-white illustration at the bottom-left of my visual references board above), it would allow me to add more layered waves in the background while keeping the focus of the foreground on the ship and the spiral. So I tried it out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dHxdgPDniWqK0W_dztypKA.jpeg" /><figcaption>The “crazy ocean” illustration with a wavy ribbon spiral for the abyss under the surface.</figcaption></figure><p>This illustration took quite a while to create and fine-tune. I wanted multiple layered ocean waves in the background with a lot of white abstract foaming waves on the surface. So it required a ton of refinement and polishing to get it to look good. I also wanted the ship to feel like it’s really making an impact crashing into the ocean (as opposed to just floating on it), so I also put a lot of wave detailing in the area that the ship’s hull touches the ocean surface. I also tried my best to blend the whirlpool spiral into the waves to make it feel like it was a part of the ocean.</p><p>The author absolutely loved this. It came out better than he expected, and I was a fan too. We were both skeptical of the fact that a realistic ocean with lots of swirling waves would make the cover look too busy, but the clean separation of the layered waves and stark contrast in colors balanced themselves out really nicely to create a pleasing composition. I wasn’t fully satisfied with the waves under the surface though, so I wanted to clean that up. The author also wanted some refinement to the spiral, so I set out on a round of revision to get this cleaned up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1XtJjP76R6FRrieCkmd0Zw.jpeg" /><figcaption>The final illustration for the ship, ocean, and abyss.</figcaption></figure><p>In this round of revision, I removed the floaty underwater wave strokes that looked out of place and swapped it out with a layered ocean in the foreground, which doubled nicely as a way to fade out the translucent spiral as we go downwards in the composition. I also redid the spiral to be tighter and have more rings be visible at the author’s request. And then I just brought the composition together by adding some clouds in the background and some wind effects around the ship to provide a “stormy” look.</p><p>And that was it. It only took one or two rounds of fine-tuning to get the full layout to look the way we wanted it to. We felt that this really nailed the feel that we were going for, a ship navigating a turbulent ocean which is being sucked in by an “abyssal whirlpool” underneath. The spiral stood out but didn’t dominate the composition, the ocean actually looked good, and the art style more or less matched that of the first cover while still looking compelling on its own. We weren’t done though. We wanted to try out some alternate color schemes and there was still the back cover that needed to be made.</p><h4>The final polish</h4><p>So far, I had created the illustration in the traditional colors of an ocean and a ship hull. I mostly made color choices by referencing the visual targets and choosing hues that complemented each other. This was quite different than the typical process of choosing a color palette first and applying it to the illustration. Nevertheless, we wanted to do our due diligence and explore alternative color palettes for the sake of ensuring that we weren’t dismissing a better option, so I mocked up some quick versions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sjzF75wlQN173QX6a9vj9w.jpeg" /><figcaption>Alternative color palettes for the ocean and abyss spiral.</figcaption></figure><p>In order to maintain some sense of brand continuity, I sampled the colors from the cover of the first book and tried applying it to this cover. I tried out a green ocean, a golden yellow spiral, and even had a grayscale version to really let the spiral shine. But the original color palette outweighed the alternatives for a few reasons: it ends up being a more realistic rendition using actual colors of the elements, and the waves blend into the spiral really nicely in the original version. The golden spirals felt too much like they were a positive thing that was holding the ship up in this storm, the opposite of what we wanted a depressive spiral to convey.</p><p>The author also mentioned that he was reluctant about using the same color palette as the first book here. While it does serve to be more recognizable and part of the same brand, he didn’t want to limit himself to the same color palette for the potential third book. This made sense to me. So we decided to stick with the original color scheme and move on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t0XGOIiPwutXBPj8BsO4Iw.jpeg" /><figcaption>The initial lighthouse wireframe (left) along with some visual references.</figcaption></figure><p>Next up was the back cover, and the most important piece of the back cover was the lighthouse. I had illustrated a very rough wireframe-y blockout of the lighthouse in an earlier layout where I was trying to get the composition locked down, so I had to actually begin the design for this with some visual references. The goal was for this to be simple and easily identifiable, with a simple striped pattern and a light shining out as a beacon of hope.</p><p>Statistically speaking, the back cover of a book is far less important than the front cover. If the front cover’s job is to get you curious about it and pick it up off the bookshelf, the back cover’s job is to sell you on it enough to get you to buy it. So the illustration mostly takes a backseat here and is less important. But it was still to be visually connected to the front cover through the ocean across the entire spread, so I treated it with the same level of importance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QJmNcxbLPeK3TtpsNhKazQ.jpeg" /><figcaption>The lighthouse illustration, in various color schemes.</figcaption></figure><p>So I illustrated the lighthouse using the visual targets as a reference and placed it atop a cliff on the ocean. I illustrated it in a few color schemes just to have some options to choose from. Typically, lighthouses have a high contrast alternating color scheme on the stripes to easily be visible to ships and aircraft in stormy and foggy weather, so I intentionally chose some vibrating colors to give it that easily-visible-in-foggy-weather feel.</p><p>The hardest part here wasn’t illustrating the lighthouse itself, but was making the waves crashing against the cliff look natural. This was a very turbulent ocean, so the scale of the waves and the lighthouse needed to look proportional. The lighthouse was to be at the left edge of the back cover and the ocean was to be at the bottom; the rest of the back cover would just be text. We liked the last option, the white-and-red version, the best. It fit well with the rest of the color palette and still symbolized what we were going for.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dTgl_m98qj6krDD1hnsVeg.jpeg" /><figcaption>The final illustration for the full spread. The lighthouse looks gigantic in relation to the ship, but the full illustration will never be viewed like this. The front and back covers are never visible at the same time, so the scale is faked a bit to look optically correct when flipping the book from the front to the back.</figcaption></figure><p>And there it was. The full illustration for the entire spread. I intentionally made it larger than it needed to so that it could be cropped and resized as needed. At this point, we weren’t sure of the format for the printed versions of the book and didn’t exactly how thick the spine would be (the book wasn’t done yet), so I gave it as much room as possible to scale up to a really thick hardcover book, if we ever decided to go down that route.</p><p>The entire illustration is a vector, so it could scale up and down as needed without ever losing clarity. Believe it or not, I made this entire illustration in Figma. The convenience of working on it by just booting it up from a web browser anywhere on any device totally beats any other niceties that Illustrator offered, and it worked out great.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZb8VMcH2lQ0rAyHuJK39w.jpeg" /><figcaption>The final spread, with the titles and placeholder text.</figcaption></figure><p>After adding all the text in, the cover looked really solid. The scale flowed very smoothly from front to back and the full-bleed ocean worked better than I had expected. Despite all our reservations early on about having the cover be too busy, we somehow got it to look good with a strong focal point on the front cover and a visually pleasing composition overall. It even matched the layout and placement of all the titles to the cover of the first book, which the author was really happy with.</p><p>From starting with the abyss explorations to this final illustration, working on this cover was a journey. It was such a different process from that of the first book, and helps illustrate the uncertainties, pivots, and hardships in the design process really well. For all my worrying about how on earth I’d illustrate an entire ocean, I somehow managed to do it in a way that accomplished all the design goals for the book and still look good. That was the biggest sigh of relief for me, and only served to give me more confidence in my design process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T4xs4jOWTIlEnxx1RGJ7Fw.jpeg" /><figcaption>The final front and back covers for the second book, coming soon!</figcaption></figure><p>The book launched in November 2021 and is currently <a href="https://www.amazon.com/Get-Out-Your-Head-Vol-ebook/dp/B09KQ4FLBW">available for purchase on Amazon</a>. I should also note that the Get Out of Your Head brand went through a visual identity evolution after the completion of the cover but before the book’s launch, so the titles and logos on the final cover are slightly different than what’s shown here in the mockups. Additionally, observant viewers might spot minor differences in the visuals of the ship in the mockups shown here versus the final cover on Amazon. I made a few eleventh hour updates to the illustration based on the author’s request to add in a human onto the ship for a sense of scale (displayed in silhouette in front of the sails) and to add a few more detailing elements to the ship’s hull (like the railing that goes all around) to give it a more “swashbuckling” feel. The perspective of the ship also changed a bit from three-quarters to more of a profile view.</p><p>Overall, working on this second book was a huge learning experience for me. I still wouldn’t call myself an illustrator, but I’ve certainly gotten more comfortable in my own illustration abilities. There were a lot of moments in this process where I was questioning whether what I was doing was right imbued with a ton of self-doubt in my own ability to deliver good work here. The author’s feedback after every round of edits here was crucial in continually refining this illustration and making it the best version of itself. Ultimately, it’s not about the technique of illustration itself, but about how well the designer can translate the abstract concepts of the book into a visually coherent message that comes across immediately and easily.</p><h3>Illustrating book covers</h3><p>My design process here for both these covers may have seemed unconventional to many. I didn’t start with an established visual style and color palette that you might see in many design process case studies. I intentionally wanted to keep the early explorations somewhat rough (even the high-fidelity ones) and feeling like they’re still a work-in-progress when I present them to the client. It really helps me tighten up all the rough edges without seeming like I’m controlling the aesthetic direction too tightly.</p><p>Staying flexible and open to change throughout the entire process is actually more beneficial to the end product. The brain glove on the first cover didn’t look good until I made it look less intimidating through many revisions. The nautical theme for the second book would have never been settled on if I had too quickly locked into a solid visual direction for the abyss explorations. Artists tend to say something along the lines of “letting the work create itself” through discoveries, breakthroughs, and refinement as they continually work on it, and that approach seemed to work really well for me here.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r9y3A9vdymeIocWk1cb-HA.jpeg" /></figure><p>As mentioned earlier, <a href="https://www.amazon.com/Get-Out-Your-Head-Overcoming/dp/1732932611/">Volume 1</a> (with its updated cover) and <a href="https://www.amazon.com/Get-Out-Your-Head-Vol-ebook/dp/B09KQ4FLBW">Volume II</a> of Get Out of your Head are available on Amazon. <a href="https://getoutofyourhead.com/about/">Brian Sachetta</a>, the author, has a very trustworthy and relatable writing style when it comes to talking about such difficult topics, and I’m glad he’s able to establish a name for himself in the mental health space through these books.</p><p>The Get Out of Your Head brand has been firmly established for any future books, and there exists a basic layout and design pattern from the two existing covers that can easily scale up to a series of books. I’m just glad that I was able to work closely with him to capture the essence of the book’s message in a visually compelling manner on its cover, and I sincerely hope that these books prove to be useful for anyone struggling with anxiety, depression, and other mental health issues.</p><p>I’m happy to answer any questions that readers might have about my design process and the illustrations. Feel free to post a response to this story or get in touch with me via email at dakinedi@gmail.com or hit me up on <a href="https://twitter.com/a_kill_">Twitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb5995c87b90" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Behind the Design: Rethinking support messaging in the Lyft app]]></title>
            <link>https://medium.com/lyft-design/behind-the-design-rethinking-support-messaging-in-the-lyft-app-5c8fa3e7bc8b?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c8fa3e7bc8b</guid>
            <category><![CDATA[lyft]]></category>
            <category><![CDATA[messaging]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[service-design]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Tue, 20 Apr 2021 23:38:00 GMT</pubDate>
            <atom:updated>2021-05-04T21:49:54.141Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cuy-_UZ-IlXaSoSrRQBC7A.png" /><figcaption>Illustration by <a href="https://medium.com/@HannahCDesign">Hannah Chen</a></figcaption></figure><p>I’m a Product Designer on Lyft’s Safety &amp; Customer Care team, where the work primarily involves ensuring that Lyft riders and drivers are able to get the help they need in the event that something goes wrong with their Lyft experience. Much of this involves providing a digital interface and solution in the Lyft app to an interaction or problem that occurred in the real world, and designing for these scenarios can be both challenging and fun.</p><p>After a project is complete, I enjoy breaking down and demystifying its design process to showcase all the early thinking, scrapped ideas, and iterative refinement that goes into it. Even the simplest and most seemingly straightforward features require a surprising amount of design considerations to think through, prototype, and validate. Lyft support history is one such feature I worked on that recently shipped to Lyft riders and drivers, and this post documents the end-to-end design process for it in detail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3HxVGYctwrvuxjFvy5W_Aw.png" /></figure><h3>Getting help in a pinch</h3><p>Let’s paint a picture. Zoe calls a Lyft ride to get to a doctor’s appointment, and Lyft says that her driver, Albert, is on his way and should arrive in six minutes. On his way, Albert is forced to take a detour due to construction and drive slowly in single-lane traffic, increasing the ETA to eleven minutes. Meanwhile, a frustrated Zoe decides to cancel the ride and try alternative options to get to her appointment on time. Zoe then gets charged a cancellation fee because the driver was already on his way to the pickup point.</p><p>Both Zoe and Albert have now had a bad experience with Lyft. Zoe feels that she shouldn’t have to pay for this cancellation fee, and wants to dispute this charge with Lyft. Meanwhile, Albert has not received his cancellation fee to make up for the time he spent driving to Zoe’s pickup point, and wants to inform Lyft of this issue so he can get paid correctly. Both Albert and Zoe navigate to the Help tab to get their issue resolved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*geMPbLebHm5wyid5uEnnEw.gif" /><figcaption>An example flow for how a driver would go about getting in touch with Lyft Support for a cancellation fee issue. Once the issue is resolved, the chat is available for 24 hrs, after which it disappears from the app.</figcaption></figure><p>Let’s take a closer look at Albert’s issue. In the Help tab, Albert reads through the available content and feels like he still hasn’t gotten the help he needs. He decides to contact Lyft and describes what happened. He chats back-and-forth with a Lyft support agent for a bit, and is then issued a refund of the cancellation fee into his account. Relieved that his problem has been resolved, Albert moves on. Zoe goes through a similar flow on her end and gets her cancellation fee waived by chatting with Lyft Support.</p><h3>The problem with chat support</h3><p>Imagine that it has been several months, and Albert has the same issue about not receiving a cancellation fee yet again. He probably remembers the issue happening sometime before and having gotten it resolved somehow, but it’s been a while and he has since given hundreds of rides. How does Albert go about looking up his earlier issue that he had to contact Lyft Support about?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y5B6PPEnBOwzsx0NMaV7GQ.png" /><figcaption>Closed chats are only viewable for 24 hours, after which they permanently disappeared from the app 😢</figcaption></figure><p>The problem is that he <em>can’t</em> look it up. Chats with Lyft Support weren’t saved in the app after they were resolved, so they just…disappeared. There was no saved record of the chat with Lyft Support anywhere. Our UX Research team discovered that this led to a lot of confusion amongst riders and drivers. Here’s a small taste of the quotes that came out of these discovery sessions:</p><blockquote>“Lyft doesn’t keep a thread of the chat in the Help section, so I can’t look at it anymore. If I was smart, I would have screenshotted it before it disappeared.”</blockquote><blockquote>“A history would make it easier to check what Lyft said. Right now, I can’t prove that I reached out with this issue and that all these things happened to me.”</blockquote><blockquote>“I prefer chatting through email because I can look at the emails later if I need to, but I can’t do that with chats in the Lyft app”</blockquote><p>Lyft drivers and riders constantly mentioned that wanted to reference past chats to see what they said and how Lyft responded in past issues. Many even directly alluded to the fact that it would strengthen Lyft’s credibility and standing if this kind of transparency was provided. Despite this seeming like a pretty obvious and basic feature, it wasn’t a focus or a priority for the team when the original chat support channel was built. So this set us off on a journey to build out a support history within Lyft, with its primary goal being to recordkeep and reference past chats with Lyft Support.</p><h3>Product strategy</h3><p>As we started diving into the work in this early stage, I was closely collaborating with my Product Manager to break down the work into usable milestones and closely reviewing the PRD to better understand what is and isn’t in scope for the very first milestone of this launch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AAFn1RB97iJlL5nhIfVCYA.png" /><figcaption>A lot of driver and rider issues were currently handled over email, a good portion of which we wanted to move over to in-app chat for efficiency and experience gains. Phone support was mostly reserved for serious safety incidents that require emergency assistance, so it wasn’t a good fit to move over to in-app chat.</figcaption></figure><p>One big question on our minds was whether to include all support channels that we offered (chat, email, and phone) in the support history. Our UX Research studies didn’t indicate a strong user preference for viewing emails in the Lyft app, as it was already available to reference in their mail client of choice. Phone calls could also readily be viewed in the call logs on the phone, so users didn’t show any strong signals for wanting this in the app either (unless we provided a transcript of the entire call in the app, which we didn’t have the technical capability for at the time anyway).</p><p>So we decided to focus our first version of this feature launch on <strong>chat only</strong>, as this was the channel with the highest volume of support issues and was the one for which users signaled the strongest user preference for having a support history accessible in-app. This also aligned with our internal business goals at Lyft, where we wanted to move more of our support issue volume from emails and phone to the chat channel. The asynchronous nature of back-and-forth messages meant that Lyft support agents could handle as many as two or three different issues simultaneously, increasing their resolution rate and providing faster support to Lyft riders and drivers via chat.</p><h4>Success criteria</h4><p>How would we know that we solved the problem? One signal of success would be a reduction in the number of support tickets created. Since chats aren’t preserved in the app, Lyft users often create multiple support tickets for the same issue, which results in quite a lot of duplicates in Lyft’s internal support ticketing systems.</p><p>Support history was meant to be a foundational platform on which to build more features to tackle the duplicate tickets issue. So with the help of our data partners, we determined our success criteria to be a <strong>reduction (or neutral impact) </strong>in the overall number of support tickets created as well as a <strong>reduction</strong> in number of duplicate tickets created. We would measure the impact through experiments and determine if any changes needed to be made before launching.</p><h3>Design principles</h3><p>Another thing I established with my PM early on was a set of design principles that would guide our thinking and would serve as a benchmark to evaluate the ideation and explorations around. These were:</p><ol><li><strong>Simplicity: </strong>the level of detail and visual treatment of each support issue needed to be concise and immediately clear at a quick glance</li><li><strong>Ease of accessibility: </strong>finding and accessing open chats needed a low level of cognitive effort</li><li><strong>Transparency: </strong>current status, response expectation, and behavior or timing expectation for each chat was clear</li><li><strong>Scalability: </strong>design should be able to accommodate issues handled in other support channels (email &amp; phone) in future versions</li></ol><p>These principles served as an excellent framework to always come back to whenever we were debating a design decision later. They helped boil a conversation down to basic questions framed around our goals, like “<em>Does it align with our design principles?</em>” and “<em>Is the design accomplishing all these objectives?</em>” rather than veering off into irrelevant territory.</p><h3>Messaging in the Lyft app</h3><p>I also wanted to better understand how support history would fit in with the rest of the messaging ecosystem in the product. Currently, there’s a few different types of chats that can be triggered in the Lyft app:</p><ol><li><strong>Coordinating pickups: </strong>a chat between riders and drivers in the event that they can’t find each other at the pickup point</li><li><strong>A lost and found item issue: </strong>a chat between riders and drivers in case a rider leaves behind an item in the driver’s vehicle</li><li><strong>Contacting Lyft Support about an issue: </strong>a chat between drivers or riders and Lyft Support to get a variety of issues resolved</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3LENGLcZdY69h7x4m6MJcQ.png" /><figcaption>Riders and drivers chat with each other to coordinate pickups (left) or resolve a lost and found issue (middle). Riders or drivers chat with Lyft Support (right) for a variety of reasons including issues with rides, payments, earnings, refunds, and safety incidents.</figcaption></figure><p>None of the these chat conversations are currently saved anywhere in the Lyft app. Designing a feature that hosted a history of Lyft Support chats in the app meant that riders and drivers may come to expect other conversations to be saved in there as well. The big question on my mind was whether or not it made sense to unify the other messaging surfaces in one place in the app? 🤔</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IKvlomeHHV8o_xQ7FmFc8w.png" /><figcaption>A visualized ephemerality framework to map out the messaging landscape in Lyft. A case was being made to have support history save all but the rider-driver pickup coordination chats in the Lyft app.</figcaption></figure><p>After thinking more deeply about the case where riders coordinate pickup points with drivers, looking up past research findings, and talking to the other teams who worked on these features, I came to the conclusion that the chats where riders and drivers contacted each other to coordinate pickups didn’t have as strong of a need to be saved for perpetuity in the Lyft app. If anything, they just added noise and served to re-trigger negative emotions of past pickups that didn’t go smoothly. Most users had likely forgotten about these situations anyway, and past UX Research suggested that having these saved in the Lyft app wasn’t top-of-mind for riders and drivers.</p><p>Lost &amp; Found was an interesting case where there <em>was</em> a compelling reason to save them. The chat transcript served as proof of contact between the rider and driver, and the messages typically confirmed whether the item had been returned or not. There were also some great considerations and safeguards built-in here to ensure that these chats couldn’t escalate into uncomfortable situations like harassment or unwanted contact, so we decided that it made sense to keep these in the support history.</p><h3>Low-fidelity design explorations</h3><p>Once I had a good sense of the space I was working in and had all of the product requirements clarified, I finally got to thinking about the interface. There were three main areas I was focusing on:</p><ol><li><strong>The entry point to support history: </strong>How would users actually get to it?</li><li><strong>The support history screen: </strong>What was the best way to display the information most effectively?</li><li><strong>The messaging screen: </strong>What (if any) updates would we need to make here to complete the feedback loop with users?</li></ol><h4>1 | The entry point</h4><p>Some important context: if Lyft riders and drivers have an open support chat, they’re usually notified of new messages through system push notifications (there are safeguards into the system to ensure that drivers don’t receive these notifications while they’re driving). Tapping the notification takes them directly to the chat. But what if they ignored or dismissed the notification and they needed to be informed about new messages in their chat with Lyft Support in-app? This is what I focused the exploration on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JAToi36-dRBzjL3OKLsEIQ.png" /><figcaption>Low-fidelity wireframes (that looked like in-progress, unfinished sketches) helped center the discussion and feedback around the IA and UX of the feature. I was working with “Support Inbox” as the placeholder title of the feature, which was also the internal name of the project.</figcaption></figure><p>One option (A) was to have an icon in the right of the header with a badge in it. Tapping it would go directly to the support history screen. The questions I had here were around whether or not the icon would persist across all the deeper Help screens or not and what the badge would represent (number of open support chats or total unread messages across all support chats).</p><p>Another option (B) focused on having a card with a live message preview including a status. Tapping the message would go directly to the messaging screen but tapping the CTA below it would go to the support history screen. One natural question this bought up was how users would access the support history screen if there weren’t any open support chats. This led me down a path to explore whether Option A and B could work together as one combined entry point.</p><p>I did another quick exploration (C) to split the Help screen into two tabs, which felt like a nice slick interaction but also added more navigation and cognitive effort into the header for users who didn’t have any open support chats at the moment, so I decided to just scrap this and pursue the idea of combining Options A &amp; B for the entry point in the higher fidelity mocks (more on this later), which complied really well with our design principles.</p><h4>2 | The support history screen</h4><p>In theory, designing this view sounds easy enough, as it just needs to display the open and closed support chats. But what’s the right level of detail needed in each chat? How do we communicate a status on each chat? How do we properly indicate which chats are waiting on a response from the user and which ones are just being worked on by Lyft support agents? Where is the line between clarity and information overload? These are the kinds of questions I was asking myself as I started exploring the layouts in this screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6N2rM9hAcMaGxGpTt_TEug.png" /><figcaption>Lo-fi design explorations for the support history view. The design borrowed a lot of patterns (like unread dots on the left) from existing messaging/email apps since the association with those mental models was strong.</figcaption></figure><p>One idea (V1) was a simple split list that was separated by open and closed chats. Another (V2) was to try using the tab navigation in the header here, hiding away the irrelevant closed chats and only focusing on the open ones;. While good in theory, this felt like it was over-solving for a high volume scenario, which we weren’t expecting in the feature at launch since users could only have one open support chat to begin with. So V1 was the right path forward.</p><p>In both these explorations, the issue that the user selected before triggering the chat would become the de-facto “title” of the chat, as we already knew this served as a strong anchor for users to differentiate between chats while looking through them in a list. Also visible in these explorations are my early attempts to provide some degree of transparency about the status of these chats to the user. I was playing around with a system where the status for an open chat would rotate between “<em>Awaiting your response</em>” and “<em>Awaiting Lyft’s response</em>” to try and see if that’s useful for users to understand when the chat is waiting on information from them and when it’s simply being worked on by the Lyft support agent. Similarly, the “<em>Closes in X hrs</em>” status served to just inform the user that the resolved chat was scheduled to close out after a certain timeframe.</p><p>Another important consideration to be aware of here was that this view would also host the Lost &amp; Found chats between riders and drivers. While I didn’t spend too much time iterating on what the differences between those chats and the chats with Lyft Support would be, I was closely collaborating with the other designers involved in that work to ensure that this view would be able to host those chats as well.</p><h4>3 | The messaging screen</h4><p>This screen already existed, but needed some updates. For one, it currently wasn’t displaying what the issue was. It also didn’t show any details about what ride it was for (which is important because a rider or driver could have the same issue on multiple rides) and had no visibility about the status of the chat. So I tried to work all these into it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Bg0Zsz3gjsldzjeOBKxVQ.png" /><figcaption>The old messaging screen needed some updates in order to adhere with our new design principles</figcaption></figure><p>The same anchoring issue title became the new screen header here, and an additional line item was added for the ride details. I was tinkering with what the best way to display the statuses would be in this view, and was experimenting with a layout where it showed up right after the last message in the chat. The idea was that this would either prompt the user to respond or just hang tight until the support agent got back to them. One of our design principles was to be transparent about the status of a given chat, and this served to provide some clarity.</p><h3>Design iteration &amp; feedback</h3><p>These low-fidelity wireframes were crucial in having some kind of visual aid that the rest of the team could reference and get an early idea of how the feature could manifest in the app. They also played an essential role in doing quick feasibility checks with the engineering team to make sure that everything I was suggesting here was actually technically possible to do.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r1EcXDKy4pTvg9LjxXjKlA.png" /><figcaption>The low-fidelity screens that I shared out with my team to get a sense of what is and isn’t working. Shown is the combined entry point where the card as well as the icon in the right of the header is visible (from where the inbox is accessible even when the card doesn’t show up).</figcaption></figure><p>One thing that my PM and engineering partners wanted more context on was the statuses. How many would we have? How would they move from one status to the next, and how would we even detect these? I had done a deep dive into what the user would need to see here, but how would this work as a system? I brainstormed this a bit with other designers, and figured that each chat would rotate between one of four statuses:</p><ul><li><strong>Routing to a Lyft agent:</strong> An open chat is being assigned to a support agent</li><li><strong>Awaiting your response: </strong>An open chat is waiting on a user response</li><li><strong>Awaiting Lyft’s response: </strong>An open chat is being worked on by a support agent</li><li><strong>Closes in X hrs: </strong>A resolved chat is about to get closed in X hrs</li></ul><p>While these were all striving for transparency, they also may be communicating too much information. Design reviews with my peers helped reshape my thinking around this to simplify and streamline the experience further. I needed more feedback from users to make a decision on whether or not the statuses help or hurt the decision-making when keeping track of a chat with Lyft Support, so I tabled this until we could test the design with users and validate some of the core assumptions here.</p><h4>Scaling support history</h4><p>Another point my design partners bought up in feedback sessions was to really hone in on how these designs were aligning with the design principle focused on scalability. What would support history look like if there were multiple types of channels in there? We intentionally decided to leave out phone and email support issues as part of the product strategy in this project, but how would the design scale to handle it in the future if it needed to? It’s important to do this exploration to visually convey the problems that would arise and get people thinking about it sooner rather than later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fl_bPiXxuKIivwu7DXrqDA.png" /><figcaption>A quick design iteration for what a multi-channel inbox could potentially look like, with the support channel that the issue was handled in indicated by icons on the left.</figcaption></figure><p>So I did a quick mockup of an icon-based approach to try this out. My concerns with the multichannel expansion of support history were that the Open/Closed bucketing doesn’t exactly make a ton of sense here. Emails can technically be “re-opened” at any time by replying to it and phone calls would only live in the “Open” bucket while they’re ongoing, after which they move to the “Closed” bucket. We had a similar issue with the unread indicators, where emails could be “read” in an email client outside the app and phone calls would just never change state between unread and read, making the design feel inconsistent across the support channels.</p><p>Beyond that, my larger concern with displaying phone and email support channels in support history was around what the detail views for those would even show. We didn’t have call transcripts and nested email views, so there were a lot of open questions to figure out here on what to display if a user tapped into an email or phone support issue. We didn’t have an answer to this at the time, but doing this multichannel exploration was a good exercise to at least start documenting the issues that we know we’ll run into in the future as we eventually scale support history to include other channels.</p><h4>Handling duplicate chats</h4><p>Let’s go back to our earlier story for a second. Albert, our driver, starts a support chat with Lyft for a cancellation fee that he never received. After going a few minutes without getting a response from Lyft, Albert decides to trigger another chat by selecting a different, seemingly more serious issue to see if he gets a faster response. Albert now has two open chats where he wants the same problem resolved. Which chat should the resolution happen in? What do we do with the other chat? What does Albert expect to happen in this situation? What’s the best way for a Lyft support agent to handle this? This is just one of many complex situations that we could end up in and needed a solution for.</p><p>This scenario might sound like an edge case, but we still need to account for it. For many reasons beyond our control, chats sometimes get routed inefficiently and incorrectly to various support teams. This can be a very frustrating for the Lyft driver or rider, because they‘ve already had a negative experience with the platform and aren’t even able to get a response from Lyft Support. From a technical side, it’s expensive to have extraneous chats that just stay open where no conversation or resolution is happening, so there is a very real cost factor at play here.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fBs-4_-3_QMXVbqTzhWmhg.png" /><figcaption>A flow that I put together to visualize all the state changes that two duplicate chats would go through once the Lyft support agent handles the duplicates on their end. This is what the user would see on their end as the chat state updates.</figcaption></figure><p>My solution here was to redirect the user to the chat where the resolution is actually happening if they find themselves in the duplicate chat that the support agent decides to close out. There’s a lot happening here in the backend where the support agent has to do quite a bit of work to figure out which chat to resolve the issue in, and it gets really complicated really fast. I was proposing that we handle much of the complexity on Lyft’s backend so that riders and drivers are crystal clear on what’s actually happening without requiring them to do too much work. But I also needed to ensure that Lyft’s support agents wouldn’t get overwhelmed with a series of manual tasks that would hurt their resolve time metrics. The trick was striking the right balance between these two goals.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*edmgimUZJz7-t8huu6VNxw.png" /><figcaption>My (condensed!) flowchart of what’s actually happening behind-the-scenes in this duplicate chat resolution workflow.</figcaption></figure><p>I ended up with a workflow that automates much of the trivial decision-making involved in the Lyft support agent’s workflow while still requiring almost no input or effort from the riders and drivers. This workflow ended up making a great case to invest even more time into updating the tooling software that Lyft’s support agents use to resolve these issues (which I also worked on; more on that in a different blog post).</p><p>Figuring out this duplicates workflow was quite a deep dive into systems thinking and ensuring that the flow would work for users opening chats from the Lyft app and support agents closing the chats from our internal support tools. This is a good example of the kind of work designers are doing more and more of these days — to think broadly and more strategically about the people involved in the system and the problems we’re trying to solve for them—and I hope to see more posts and case studies written about this.</p><h3>User testing</h3><p>After much design ideation, low fidelity iteration, and making flowcharts, it was time to actually user test my designs. We decided to test these at the same low level of fidelity so that users would give the type of feedback we were looking for. Time is money with user testing, and we wanted to make sure we got directed, actionable feedback about what we were testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nUDKKRUiCoZUWgyLTxYJLA.gif" /><figcaption>The flow we tested in user testing, where users navigate to the Help tab to check on a new message from Lyft Support as well as navigate back to Help after the chat has been closed to test if they’re still able to find it.</figcaption></figure><p>I stitched together my designs into a prototype flow and collaborated closely with our excellent UX Research team and tested it with eight Lyft drivers, all of whom had chatted in the past with Lyft Support. Half of them had their issue resolved whereas the other half weren’t satisfied with their resolution. We also directly asked the participants several questions about their expectations during the testing sessions. After everything was said and done, the big takeaways were:</p><ul><li><strong>Most participants expected to only see chats in support history. </strong>They mentioned that they could check their phone or email app to look up issues there, so they didn’t expect to see phone or email issues here.</li><li><strong>Drivers clearly understood open vs. closed chats</strong>, but wanted the open chats to stay open longer in case they wanted to dispute the resolution.</li><li><strong>The level of detail in support history was sufficient</strong>, but the statuses weren’t as useful because they were often repeating the same information the agent was telling the user in a different way. There was also a risk with users not responding to an inquiry until they saw “<em>Awaiting your response</em>,” an issue exacerbated by potential errors in chat state detection.</li><li><strong>Numeric badges</strong> proved to be a useful navigational tool to find an unread message.</li><li><strong>Some drivers didn’t immediately identify the inbox icon</strong> on the right as the entry point but were able to find it after some digging. Adding a guided message when the feature rolls out would help with this.</li><li><strong>“Support history”</strong> worked better as a name than “Support inbox”</li></ul><p>These were all highly actionable and useful. This was more than enough information to decide that we could likely kill the statuses due to a mismatch in user expectations of not responding until a status change triggers, the statuses themselves distracting from the actual conversation, as well as the complexity involved with ensuring that the chat state detection worked correctly. We also wanted to keep the dual entry points when there was an open chat, use “Support history” as the name, keep the chat open for 24 hours before it closed (even after resolution), as well as add an informational tooltip on the inbox icon to better help users onboard to it at launch.</p><p>We also briefly tested a series of mockups showing the duplicate chats flow, but it was difficult to get the right type of feedback on this due to the highly specific scenario it involved and all the actions drivers would have needed to take to even get into that state. We needed to iterate and explore a bit more on this flow anyway due to other dependencies on the support tooling updates, so it wasn’t a dealbreaker that we didn’t get great usability feedback on it.</p><h3>Finalizing the designs</h3><p>One of the benefits of having a <a href="https://design.lyft.com/building-a-design-system-library-3a1f0d09088f">robust component library</a> is that most of the patterns used in the product are already defined and spec’d, so updating wireframes to high fidelity mockups ends up being the fastest part of the design process. There’s little to no debate about the interface details like layout and spacing since it has all already been thought through. This frees up designers to spend most of their time thinking through the larger user journeys and UX problems, since most of the UI details are handled with a plug-and-play design system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ZM98AUxtGTtgJP_dHWmcw.png" /><figcaption>High fidelity mockups of the three main screens, including all the copy updates.</figcaption></figure><p>Finalizing the designs also involved closely collaborating with our UX Writing team to ensure that all the copy that we’re using across this feature is consistent in tone and voice across the Lyft app. We updated “Support history” to “Support chat history”, changed “Open” to “Active”, and make some tweaks to the language and wording of the automated messages that are sent inline to communicate the frequency and expectation of responses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NoNhPUF7ckxLqluXl82HNA.png" /><figcaption>Android version using the relevant components from our design system.</figcaption></figure><p>A few more housekeeping items were left to take care of, the first of which was to create the designs for the Android version. Most of this is identical to the iOS version, save for some minor differences with how tap affordances are indicated and text alignment in the header.</p><p>Another consideration to deal with was Dark Mode, which was turned into a one-button action through the amazing <a href="https://twitter.com/alexjlockwood/status/1288340920128032768">Dark Mode Switcher plugin</a> that was created internally at Lyft. The plugin automates all the color palettes and typography styles in the designs to instantly switch to the Dark Mode version. It works like magic and still blows my mind that this is possible! ✨</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CfzLtVXA6C8thJm-jw7P_A.png" /><figcaption>Dark mode versions of the high-fidelity mockups (iOS only shown)</figcaption></figure><p>The last design task was to actually get the inbox icon added to our design system. It didn’t exist before this feature, and we need all icons to exist in the design system for them to be used in code. So I created the icon at all the required sizes (XL, L, M, S, XS) following the keyline grids and metrics as a guideline and reviewed it with the team. After reviewing it with our illustrators, it was approved and added into our design system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5826YCW6zlnvjy0fzXRzMg.png" /><figcaption>The final inbox icon that I created, in all sizes and usage context in the header</figcaption></figure><h3>Wrap-up and handoff</h3><p>Once all the design tasks were taken care of, it was time to hook up the final prototype and walk through the prototype with the rest of the team. There were some minor changes that ended up being made in the screens, but the majority of the design was able to get built as designed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ieIEamnL8-YUogAf7ZcitQ.gif" /><figcaption>The final prototype flow, showing how a driver would access chats when Lyft Support has sent a new message (along with what happens to it after it has been closed, with duplicate chats accessible from the main chat)</figcaption></figure><p>Another piece of the puzzle to clearly illustrate in the UI was the duplicate chats flow. I used my earlier workflow diagram and the chat states to lay out what’s happening in each screen — the main inbox and both the chats — as the user tries to get a resolution with two open chats for the same issue. Again, a lot of this comes down to how the Lyft support agent decides to handle things on the backend, so I laid out the worst case scenario. The solution was to redirect the user to the “original” chat where the resolution was actually happening (even if the chat title didn’t exactly match the issue description). It’s a compromise between allowing support agents to resolve the issue as they see fit and clearly indicating to the user what’s actually happening.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NCPZMB-_uiqVyHcSTC9Whg.gif" /><figcaption>A six-step breakdown of what’s happening in each screen as the user tries to get a resolution for the same issue in two open chats. It served as a great reference to illustrate what the user needs to be seeing in each screen in the event that they happen to be looking at that specific screen during any of these steps</figcaption></figure><p>An important disclaimer: the duplicate chat flow is currently undergoing lots of internal changes due to dependencies on various tooling and backend systems, so the final version may change from what’s shown in these flows. The purpose of these prototypes is to display all the design thinking that went into ensuring that the system would be able to handle these types of scenarios (even if they occur very rarely).</p><p>Aside from this, my work at this stage mostly involved working with engineers to clarify functionality, answer questions, and review test builds. As with any project, there were times when we had to compromise on certain niceties to deliver value quicker. Our earlier UX Research sessions proved immensely valuable to reference here in order to learn what absolutely must stay the way it is and what has some wiggle room for change. The design principles we established early on still worked as an excellent framework to backup decisions we made late in the build stage.</p><p>As a result of the launch experiments, the 24-hr window for which a chat stays open was changed to be 1-hr due to high costs of keeping a chat open for that long in combination with the learning that most user responses took place within the first 5–8 minutes of a chat informing the user that it would close in 24 hours. We also noticed an overall reduction in the number of support tickets submitted (across rider &amp; driver) as well as a statistically significant reduction in the number of duplicate tickets created, which was enough to make the decision in launching out the feature to all users.</p><h3>Closing thoughts</h3><p>At the end of the day, the feature itself is fairly straightforward and the way it manifests in the interface isn’t anything spectacularly different from what you might initially imagine when tasked with designing an in-app inbox. But it takes a lot of effort to keep it simple. The natural mode of operation when designing a feature is to do too much and add a lot of information where it isn’t really needed. We ended up scrapping a lot of the excess and honed in on the essential through continued tweaks. It’s a process of iterating, refining, testing, and refining again until it’s as simple and clear as it can possibly be.</p><p>The most intriguing aspect of this entire project for me was learning how to keep the decision-making for users to a minimum. Designing for support means designing for stress cases, situations where users have already had a negative experience on the platform and are annoyed that they cannot find a resolution. They’ve already jumped through so many hoops to even get to the point where they need to message a Lyft support agent, so designing for these situations requires a concentrated effort to reduce or entirely eliminate the complexity on the user’s end by handling it in a well thought-out experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_6xgf9g8olRNRuPoUBcghg.png" /></figure><p>The best tip I have for others designing similar features is to leverage your storytelling skills as much as possible. Instead of framing everything into user stories and features, talk about the problem in the context of someone having an issue: “<em>John didn’t get paid enough for this ride and wants to keep track of what Lyft is doing to investigate and resolve this issue. What’s the best way to get him the help he needs?</em>” is a far more powerful starting point to start designing the solution as opposed to getting bogged down by technical and system capabilities. In addition, use prototypes to talk through your thinking as much as possible. It actualizes thoughts and ideas into an interface that everyone can rally around, even if it is super low-fidelity and lightweight.</p><p>Support chat history is now available on the Lyft Rider and Lyft Driver apps (on both iOS and Android). I have to give huge shout-outs to my Lyft colleagues, without whom this project wouldn’t have been possible: Nicole Pearce, Sarah Zhou, Mihir Mathur, Jeffrey Chen, Sara Craba, Nicole LeBlanc, Jeannie DeLoach, Aneri Chouhan, Jen Williams, Jacob Moore, Sahil Grover, Greg Susko, Jerimiah Gazlay, Brett Jones, Matt Kent, Christian Shrader, Evan Spight, Nico Magana, Elena Glaeser, Daniel Sumstine, Christopher Wing, Xiaolong Feng, Jack Johnson, Julio González Menéndez, Sarah Morse, Sarah Morton, Mia Barnett, Chelsea Fagan, and Dan Polaske for all their help in seeing this through to the finish line. And a big thanks to <a href="https://medium.com/@HannahCDesign">Hannah Chen</a> for the illustration used at the top of this article, as well as David Hildebrand and Koji Pereira for their help with getting this post up on the Lyft Design+ blog.</p><p>Feel free to leave a response below if you have any questions about the designs, process, work, or just want to show appreciation. Happy to answer any and all questions. Hope you found some value out of this and learned something useful to apply in your work 🤘</p><p><em>Interested in joining the Lyft Design team? </em><a href="http://lft.to/design"><em>We’re hiring</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c8fa3e7bc8b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lyft-design/behind-the-design-rethinking-support-messaging-in-the-lyft-app-5c8fa3e7bc8b">Behind the Design: Rethinking support messaging in the Lyft app</a> was originally published in <a href="https://medium.com/lyft-design">Lyft Design+</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LinkedIn Case Study: Satisfaction Predictor concept for passive candidates]]></title>
            <link>https://medium.com/@a_kill_/linkedin-case-study-satisfaction-predictor-concept-for-passive-candidates-ce39d0e6bf6a?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce39d0e6bf6a</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[case-study]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Thu, 23 Jan 2020 03:55:58 GMT</pubDate>
            <atom:updated>2021-03-13T05:40:59.012Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kRaxJ4IGzZ0uNKgf3KWMZQ.png" /></figure><h3>The brief</h3><p>I was tasked with the following prompt to create a solution for LinkedIn:</p><blockquote>Design an experience that presents job opportunities to a passive candidate, who is not actively looking for a new position. Find creative solutions that gains the passive candidate’s interest in a new position, and garners a response.</blockquote><h3>Solution overview</h3><p>I created a concept that lets passive candidates take a quick survey in order to inform the system of <strong>what they find satisfying in their current job</strong>. LinkedIn then aggregates all the data of what current employees are saying about their own satisfaction levels at their jobs and <strong>displays a predictive satisfaction scale in recommended jobs</strong>, resulting in highly relevant job suggestions for the passive candidates that gains their interest and nudges them to apply.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F386110464%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F386110464&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F848513495_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1802" height="1440" frameborder="0" scrolling="no"><a href="https://medium.com/media/99801dfe5c2776f4e9369b14c3d36baf/href">https://medium.com/media/99801dfe5c2776f4e9369b14c3d36baf/href</a></iframe><p>The more users of LinkedIn that take the survey, the more data that LinkedIn has, and the <strong>more accurate the recommendation is </strong>in turn. There are <strong>various entry points throughout different parts of the LinkedIn app</strong> that prompts users to take the quick survey and sells them on the value of doing so. Users can trigger the Satisfaction Predictor modal from different screens to learn how it works in-depth or change their satisfaction responses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mWuCv-Ntc8Nc3y9gwVG9XA.png" /></figure><p>With more data comes more <strong>validation and verification</strong> problems, so there’s also some <strong>crowdsourced fact-checking built in</strong> to the system. When the user’s co-workers mention something that they found satisfying about working at the place, the user is asked whether or not the company actually has the perk that their co-workers had mentioned. This only becomes an issue at scale and with a larger pool of satisfaction criteria to choose from, but I wanted to ensure that this <strong>system would be scalable</strong> as more people used the feature and as more data was being collected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QyD6xtq9iQhEJ23jzKP5wQ.png" /></figure><p>The interactions for the survey were designed to be quick, simple, and intuitive. The visual branding tried to keep to LinkedIn’s brand guidelines as closely as possible while also trying to <strong>differentiate itself from everything competing for the user’s attention in content heavy views</strong> like the home feed. The designs were <strong>tested and validated</strong> through the wireframing, visual design, and prototyping phases of the process and were continually tweaked and refined based on user feedback. The rest of this post goes into my design process and explains how I arrived at the final designs shown above.</p><h3>Design process</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qm4vlGT7WdKmdYsEbjLpwQ.png" /><figcaption>A rough outline of my typical design process. I try to incorporate user testing into each stage towards the end rather than doing it all at once, as I find that it’s easier to learn better and faster about the different things in each stage by only testing those variables while not worrying about the rest.</figcaption></figure><p>My design process begins by <strong>understanding</strong> the core issues of the users I’m solving for. Then I try to narrow down the problem space to one core problem that I’ll be tackling and try to <strong>define</strong> it with a problem statement. I then try to diverge into as many ideas as possible in the solution space during the <strong>ideation</strong> phase and converge onto one or two key concepts. From there, it’s all about fitting it into the interface: <strong>wireframing</strong>, <strong>visual design</strong>, and <strong>prototyping</strong>, with bits of user testing sprinkled in throughout the later stages. At the end of the process, I have a solid concept that’s gone through every stage of the process and has been validated with users.</p><h3>Understand</h3><p>As I got started with my research, one of the very first things I needed to do was collect some data about passive candidates to generate insights that could be framed into a problem statement. This would then guide my thinking through the rest of the design process. My goals were to <strong>understand the motivations of a passive candidate</strong> and <strong>learn how they currently use LinkedIn</strong>. With this information, I’d be able to leverage what interests the candidates and merge it with how they currently used LinkedIn, without too much of an upfront cognitive load.</p><h4>Quantitative research: Survey design</h4><p>I used <a href="https://www.typeform.com/">Typeform</a> to create a simple survey that was split into two parts. The first section was geared around understanding more about the passive candidate. The survey <strong>automatically filtered out active candidates and candidates who weren’t interested in new jobs</strong> by ending the survey before they progressed too much further in the flow and biased the rest of the answers. It only let passive candidates progress deeper into the flow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8piKbFiOty-l_uTdlzhiPA.png" /><figcaption>The Typeform survey flow that I created for the first portion of the survey. It focused on filtering out unemployed candidates, candidates who were actively searching for new jobs, and candidates who weren’t interested in new positions at all. Passive candidates could progress to Questions 3 &amp; 4 where they could answer with multiple choice selections, along with an “Other” option where they could type out a freeform response.</figcaption></figure><p>Once I ensured that <strong>only passive candidates could progress further through the flow</strong>, I put together a list of the best responses that would be most appropriate for a passive candidate (based on my own judgement and some light online research) as multiple choice selections, while ensuring that they always had the option to choose “Other” and enter a freeform text response with something that wasn’t accounted for in the options.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cJ25rOkS2D_vVisrdhx1PQ.png" /><figcaption>The second part of the survey looked at the passive candidates’ usage of LinkedIn. If they weren’t LinkedIn users, it ended the survey. If they hadn’t seen recommended jobs before (or had seen them and had applied), it also ended the survey. This flow tried to really get to the core of why a passive candidate who had seen recommended jobs but decided not to apply chose to do so. The final questions was another multi-select option with a freeform “Other” option.</figcaption></figure><p>In the second part of the survey, I wanted to understand the passive candidate’s usage of LinkedIn. I put down common use cases for LinkedIn to see what parts of the product they find themselves going to (which would inform where to focus in on), and whether or not they had applied to recommended jobs they had seen. This portion of the survey was more aggressive, ensuring that <strong>only the truly passive candidates who hadn’t applied to any recommended jobs answered the final question</strong>.</p><p><em>Note: This survey only accounts for the passive candidate’s application to recommended jobs they see on LinkedIn, not their interactions with recruiter InMails. I decided that there were far too many variables involving personalized messaging and dimensions dealing with human nature that are far too subjective to tackle as a part of this problem, so it was left out.</em></p><h4>Quantitative research: Survey results</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ryZp1G3Rmh--v_ckAHo-DQ.png" /></figure><p>I posted the survey to anonymous social media platforms with some very basic requirements to take the survey: the participants should preferably not be a student and should preferably already employed somewhere. Because <strong>the survey self-filters out non-passive candidates</strong>, I didn’t need to specify that everyone who takes the survey must be a passive candidate. The compromise here is that I’d need a large enough sample size for the 24 hrs that I would be running the survey. I also tried to keep the survey as quick and simple as possible without requiring participants to fill out long winded responses, which resulted in a fairly quick completion time. The survey ended up receiving a total of 53 responses in a day. <strong>12 people made it to the final question</strong> after filtering out the rest, which is decent and higher than I had expected. I closed the survey after a day (due to time constraints and needing to move on to the next stage of the design process) and tried to see if I could generate any meaningful insights from the results.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Aw2eSjSAGfL814Y-ZqGk6Q.png" /><figcaption>The results for the first part of the survey (selected “Other” responses shown in floating text boxes). A good chunk of the respondents seemed to be passive candidates. I also personally sent over the survey link to people I knew were passive candidates in my own professional network, so it doesn’t surprise me.</figcaption></figure><p>There were some meaningful results here. For the first part of the survey, the <strong>#1 reason for a passive candidate not wanting to explore new opportunities was that they were satisfied where they were</strong>, and there was a wide variety of things that would get them to consider a new role. There were many different aspects to what candidates found attractive in a new role, so it was hard to pin it down on one thing. The only thing I could conclude with certainty here was that passive candidates were satisfied where they currently were, but <strong>are open to exploring opportunities at places where those things were better than they are currently</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6qHV7XaCnWhAQIxSKNppWA.png" /><figcaption>The answers in the second part of the survey deviate quite drastically for what you would expect is “regular” LinkedIn usage because everyone who made it this far into the survey was a passive candidate whose usage patterns of LinkedIn are quite different than that of an average user. The final question had some really interesting answers, with users calling out the lack of information and irrelevant job recommendations in the “Other” responses (shown in text boxes on the left).</figcaption></figure><p>As for the LinkedIn usage, a common theme that emerged was that users that took the survey seemed to getting a lot of job suggestions for companies that they weren’t necessarily familiar with, which in turn made it difficult to assess a fit due to the uncertainty in what they did or didn’t know about the companies. The data suggested that <strong>for passive candidates, information about the company was just as important </strong>(if not more) as the job details and responsibilities of the role they were applying for. This led me to believe that there’s an opportunity here to <strong>provide better company information in the job suggestions for these passive candidates. </strong>I wanted to back this up with some qualitative research as well.</p><h4>Qualitative research: Informal interviews</h4><p>I had some percentages and data points from the survey, but I also personally knew many passive candidates in my own professional network. While the survey was up and running, I also <strong>reached out to passive candidates in my network </strong>with a personalized email asking some basic questions about using LinkedIn when they weren’t actively job hunting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IaGnOk5w1QlxE5lf69qCMQ.png" /><figcaption>I was trying to get to the core of how these people (who I already knew were passive candidates) currently experienced LinkedIn. Why did they use the product? What did they do in it? The questions were deliberately somewhat open-ended to let respondents go into as much as detail as they wanted.</figcaption></figure><p>The goal with the emailed questions was to figure out if there was anything else that I’d be missing which the survey wouldn’t capture. It’s <strong>easy to unconsciously prime users into going down a certain flow in the survey</strong> by wording them in a certain way. It’s also a gamble as to whether the survey participants are genuinely answering the questions or not. Chances are a good bunch of them are just doing it to get through it as quickly as possible, so I wanted to back up my survey data with some quotes from users from my personal network who I knew would take the questions seriously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rid3M1ScCaSnyp0o1JgLDQ.png" /><figcaption>A select few statements from the email responses that helped generate insights into what problems passive candidates were experiencing with the current LinkedIn experience, which got the ideation process going.</figcaption></figure><p>The people who got back to me had a lot to say, but only some of it was relevant to what I needed to know while designing for passive candidates. Turns out a lot of the passive candidates in my network mostly used LinkedIn for occasionally dropping into the product every now and then <strong>to make connections, check their feed, and maybe respond to interesting recruiters</strong>. These responses helped close the gap in ensuring that <strong>I wasn’t missing some crucial breakthrough</strong> in the existing passive candidate experience on LinkedIn and that their issues were more or less similar to what the survey respondents had to say about their experience on LinkedIn.</p><h3>Define</h3><p>Looking at the survey results and the qualitative responses, I started to see come common themes with the passive candidate experience. They were seeing relevant jobs, but they just <strong>didn’t have the little bit of extra information they’d need to nudge them into exploring it further</strong>. They’d often get irrelevant jobs or ones where they weren’t familiar with the company. The users clearly cared about what it was like at the company and whether or not they could see themselves being happy there, but weren’t being served this information in the platform. So I started compiling these into a set of actionable insights to frame a problem statement with which to guide my ideation process.</p><h4>Insights</h4><ul><li>Passive candidates <strong>didn’t have enough information about the companies</strong> for which they were seeing recommended jobs</li><li>Passive candidates <strong>didn’t want to put in too much work</strong> to figure out whether they’d like working somewhere</li><li>Passive candidates frequently accessed three main parts of LinkedIn: the <strong>Home</strong> feed, the <strong>My Network</strong> screen, and the <strong>Jobs</strong> screen</li></ul><p>These insights were enough to craft into a problem statement.</p><h4>Problem Statement</h4><blockquote>How might we allow passive candidates to better assess a fit at suggested jobs they are seeing based on what we already know about their preferences in what they look for in a job?</blockquote><p>The problem statement is a high-level description of the goal, and is meant to only be used a guiding framework to keep coming back to if the design process gets too unwieldy. Since I knew there were many different things that different candidates preferred about a job, the <strong>solution needed to accommodate a wide variety of user preferences</strong>. I also knew that we’d need to get a baseline for what the users’ current preferences are, so that was added into the problem statement as well.</p><h4>Personas</h4><p>The last thing I needed to do before exploring ideas was to come up with a couple of quick personas to keep in the back of my head as I entered the ideation stage, so I used the insights and the problem statement to generate a couple of detailed personas that roughly <strong>outlined some of the common uses cases</strong> for passive candidates that I observed from conducting the quantitative and qualitative research.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JYkwio-o1EZlOMNxxZ73cg.png" /><figcaption>A couple of quick personas that I wrote up to make sure that my design will actually solve their problems based on what their habits, goals, needs, hesitations, and pain points are. None of this had to do with LinkedIn usage or job preferences. It was just meant to capture them as people to humanize the problem.</figcaption></figure><h3>Ideation</h3><p>Once I had narrowed down the broad problem space to focus in on one specific type of problem, I could get started exploring the wide range of possibilities in the solution space. Before I got to that, I wanted to define some constraints to ensure I could get this done in the time I had.</p><h4>Constraints</h4><p>Due to the scope and timeline of this project, I decided to keep this exploration and solution constrained to the following:</p><ul><li>Only focus on <strong>LinkedIn iOS app</strong></li><li>Only explore solutions where <strong>users are already in the app</strong></li></ul><p>Without these constraints, the solution space can get dramatically escalate in scope very quickly. I <strong>wanted to ensure I had the chance to explore one idea all the way from the initial sketch to a fully animated interactive design</strong>. So I decided to only focus on the LinkedIn iPhone app and only focus on flows where users are already in the app. There are lots of other ways to push passive candidates into the product (like emails and notifications), but I decided to put it aside for now.</p><h4>Sketching</h4><p>Typically, I tend to sketch out lots of ideas in this phase, diverging to as many far reaching ideas and concepts as I possibly can. This is all done on paper with rough sketches to get the brain going with what types of solutions we could possibly explore. My initial explorations had a lot of scattered ideas, some variations of which sort of existed in LinkedIn in a different form.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RkXICYm0Lk7K_lta9HCvUA.png" /><figcaption>My initial rough sketches covered a broad range of ideas, jumping from idea to idea and constantly generating lots of open questions around the feasibility of the whole system working as one. For each idea, I was trying to see what incentives passive candidates would have to engage with the concept.</figcaption></figure><p>I sketched out a lot of ideas on how to better assess a fit for a passive candidate. It ranged from creating entirely new sections in the product to embedded cards that surfaced new information. I started to notice a common theme in that <strong>LinkedIn as a product lacked information about what the candidates actually found satisfying in a job or a company</strong>. Sure, there’s a lot of information about skills, qualifications, and work history, but what do the candidates enjoy about work? So the sketches and ideation slowly started to shift towards the notion of <strong>gathering this information from the candidate</strong>, and some ideas started to emerge quite clearly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v6juc9ucV-VibHYsufniWA.png" /><figcaption>As the ideas started to converge, I started playing with ways of indicating a “job satisfaction estimate” to passive candidates. This was something that they could glance at quickly and figure out whether or not the job/company is a good fit for them without doing any work.</figcaption></figure><p>I started getting somewhere with the idea of predicting a user’s satisfaction level at a role or company. I realized <strong>we’d need some preliminary baseline data about what the passive candidate currently finds satisfying about their job,</strong> so I iterated on ways to ask them this information throughout the parts of the product that they most frequently visit: the Home feed, the Network tab, and the Jobs tab. The questionnaire couldn’t be too long or intensive, so I referenced a familiar role model to try and match the type of survey experience to shoot for.</p><h4>A crowdsourced recommendation engine</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CRezpuITedhIVkgrdUaLNg.png" /><figcaption>Airbnb has an excellent back-and-forth system between guests and hosts, allowing guests to rate their experience at the place and suggesting improvements to the hosts. This makes it easier for future guests to see the highest-rated compliments about a listing at a glance, giving the host an edge against less expensive listings.</figcaption></figure><p>At the end of a stay, Airbnb asks guests to leave reviews for the place they just stayed at. When enough guests respond with a certain selection, that selection gets highlighted in the listing info on the search results, <strong>prompting future guests to stay in a place that has something they’re looking for</strong>. In addition, Airbnb also <strong>fact checks host details through the guests</strong>. For instance, if the host listed the place as being wheelchair accessible, the guests get a question during their review that asks whether the place was actually wheelchair accessible to verify the listing, increasing trust in the platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7LpmdcH6Iali3jHJd3iQRg.png" /><figcaption>The feedback loop behind the core idea of a satisfaction predictor. Once LinkedIn knows what’s important to a passive candidate, it’s easier to surface more relevant job recommendations based on other candidates’ ratings about those jobs in their own satisfaction surveys.</figcaption></figure><p>What I was shooting for is not an exact 1:1 map to Airbnb’s system, but instead a spinoff that’s inspired by it. The idea was to survey passive candidates through the LinkedIn app about what they found “satisfying” in their current role. Once enough passive candidates had responded, there would be enough <strong>data to generate “satisfaction predictors” for other candidates</strong>, based on what existing employees had said. The reason this works is because at scale, <strong>LinkedIn would have enough data about what employees find satisfying to keep powering more and more relevant job recommendations</strong>, increasing the interest of passive candidates and getting them to respond to the job recommendations.</p><h4>Entry points</h4><p>This system made sense to me at an abstract level, but I needed to start visualizing how it would actually work in the product. How would we tell passive candidates to take the survey? If they don’t engage with jobs in the first place, why would they fill this survey out? How do we ensure the value proposition actually comes across in an already complex product? I started planning some of this out with a map of how the information would be layered and surfaced in the product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m4caTkPDzj61zbNYFC6rWw.png" /><figcaption>A very simplified layering of the Information Architecture of how this Satisfaction Predictor model fits in to the existing app structure. I tried to ensure that we don’t cause information overload to users here.</figcaption></figure><p>Based on the ideation, I knew we only wanted entry points to the Satisfaction Predictor from the Home feed, the Jobs screen, and the My Network screen on the LinkedIn iOS app. The basic information of what it is and how it works would be accessible from everywhere, but the embedded survey prompts would only show up in the Feed and Jobs screen. Recommendations would only be surfaced on the Jobs and Network screens. I <strong>planned this based on the information density of those screens and how much cognitive effort we’d be asking of users</strong> here. For instance, there’s already many calls to action on the My Network screen to accept connection invites and send out new ones, so adding more buttons that are demanding a response (i.e., they survey) didn’t feel right in terms of maintaining a good user experience.</p><h3>Wireframing</h3><p>I now had a good sense of what the entry points to a system like this for a passive candidate were. I also felt like I had gone through a solid process of diverging into alternate ideas and converging onto a solid concept with some thought put into the interaction model, entry points, and the information architecture. It was now time to move on to the wireframing phase. I <strong>typically start these at a very low level of fidelity and add detail as necessary</strong> based on what I need to test and learn in order to validate the experience.</p><h4>My Network</h4><p>The “My Network” tab was a great place to start, as it is very frequently visited by passive candidates to make connections and build their professional network. I tried a few layouts that explained the appeal of working at a company based on what the user’s connections had to say about it in their own satisfaction rating of their jobs. If the user finds the same things satisfying as their connections do, the <strong>likelihood of the user being satisfied at the company where their connections work is probably quite high.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yjk_FUQemwyQGlDd62anaw.png" /><figcaption>The “My Network” screen wireframes explored quite a few interaction options on how to alert passive candidates to jobs where their satisfaction would be high by leveraging their connections and highlighting things that their connections who work (or have worked) at that company have said about it. The two on the left were scrapped in favor of the clarity of the option on the right, as it was the most successful in conveying the value of the concept during user testing.</figcaption></figure><p>The swiping interactions to view multiple jobs at the same company didn’t quite feel right, as it’s not likely that a passive candidate would be interested in multiple positions at the same company. So I scrapped the idea and tried to focus on the satisfaction ratings instead. This <strong>level of fidelity was just right to put it in front of people</strong> and ask “What do you think this is telling you?”, which gave some very enlightening responses. The last option on the right was the most clear, but it also caused a lot of confusion in what the percentage number after each perk meant. It was intended to signify the percentage of people who had selected that item in their survey, but users didn’t quite get this. This led me to make this clearer (as seen in the final design).</p><h4>Jobs</h4><p>The idea to filter out jobs by the satisfaction predictor rating felt like a no-brainer. If we got passive candidates to understand what they’d get out of answering a couple of quick questions, they’d naturally see much more relevant matches in the Jobs tab. So I got to work on trying to explain this value proposition in the Jobs screen. This time around, I tried to use desaturated images of the real content in the app and notched up the fidelity of the wireframes a bit, because <strong>actual copy and images will compete for the user’s attention</strong> in the final thing. I wanted their reaction to be as accurate as possible to figure out how to best convey the concept.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W5Y790kDK5hW0Zjus8SzvQ.png" /><figcaption>Using actual data from the app to test whether the concept grabs a passive candidate’s attention, I mocked up the introductory question (left), which would dynamically update to then trigger the next question (middle). As I tried to explain how the mechanism worked behind the scenes in the same card, it started to get overwhelming, so the entire Satisfaction Predictor was split out to a separate interaction entirely, only leaving a button for users to indicate intent (right).</figcaption></figure><p>Drawing inspiration from real estate and rental search interfaces that rely on visual filtering graphs quite heavily, I mocked up a sample graph that would eventually populate to show real data of how many relevant jobs there are for each discrete level of satisfaction. <strong>The idea was to get the user interested enough about the prospect of being able to filter by their own satisfaction criteria </strong>that they’d actually engage with the options in the card. The two people I showed this to both engaged with the first CTA, but then had many questions about how this system worked, which led me to add a “How it works” section that explained everything. At this point, the card was getting long enough to fill the entire screen, so I knew this wouldn’t work. I ended up scrapping the embedded interactions in the card itself (which later found its way into the home feed) and decided that an entirely separate interaction would work even better here, triggered from the button in the last screen.</p><h4>Satisfaction Predictor</h4><p>I decided to try something very different. Tapping the button to learn more about the Satisfaction Predictor from the Jobs tab would trigger a full-screen overlay where users can absorb all the information about what the Satisfaction Predictor is, how it works, what they get out of using it, and also fact check some of the information that their co-workers have provided. My past experiences with user testing full-screen overlays often<strong> seemed to leave users confused by the sudden loss of context </strong>in what they were looking at. They didn’t want to be thrust into an entirely new flow just to learn about a new feature. Thankfully, there was a way to ease them into it with the new gesture based push modal transition behavior that came with iOS 11.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c_g2WF-FOHEHDnyUfRbw5Q.png" /><figcaption>The partially revealed modal (left) peeking into view where users can get a glimpse of what it’s all about. The swiped up state (middle) allows them to keep reading further about it and answer questions, while the scrolled state (right) lets them keep going to fact check their co-workers’ responses to the same survey.</figcaption></figure><p>When users tap the button, the Satisfaction Predictor modal peeks in partially. Users don’t lose context of the screen they were just in and can easily dismiss it from this state if they’re not interested. The hope was that they find the feature engaging enough to scroll up on it. Sure enough, the affordance to scroll this modal up was so strong as a native iOS pattern that <strong>all four people who saw the partially peeked modal scrolled up on it</strong> during user testing. In the swiped up state, users can start answering questions which dynamically keep updating as they answer them. All these interactions are still contained in this easily dismissible modal without pushing users into different flows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v8fMU3t2nLLX5Zs0d_JpTw.png" /><figcaption>Testing some of the wireframes with real users to validate some core assumptions. It was invaluable in clarifying issues with copy, content, layout, and the overall concept.</figcaption></figure><p>Overall, I was pretty impressed and satisfied with how well users grasped this interaction concept of the iOS push modal. Even non-iOS users seemed to figure out how to learn more about the feature quite intuitively, and they all answered the survey questions. Android also has a very similar pattern that can be leveraged to the same effect. This modal treatment also <strong>allowed me to give the design a lot more breathing room</strong> instead of trying to cram all the information into a feed card. The focused nature of interacting with the Satisfaction Predictor’s survey in a modal was validated, so it was time to move on to polishing it up in the visual design phase.</p><h3>Visual design</h3><p>It’s easy to go deep into iteration holes in the visual design phase. There’s always something to tweak or a new visual style to try, a small refinement here and there that could add greatly to the experience, or a completely different look altogether that can drastically change the feel of it. A good constraint to ensure that didn’t happen here was to <strong>always put the designs in context of the existing LinkedIn app </strong>to make sure that all the visual styles matched up and everything felt right.</p><h4>The Satisfaction Predictor scale</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8YqatfPaD2Ta9GqOXCCjZQ.png" /><figcaption>Various options I was exploring to indicate the satisfaction predictor scale. The radial options, while compact and efficient on space, didn’t leave much room for longer words of copy inside it and felt more like a progress bar instead of a scale. Visually indicating the user’s position felt better on a linear scale than a radial one. Users also frequently mistook the radial indicator to mean the completion percentage visual on their own LinkedIn profiles.</figcaption></figure><p>The actual satisfaction predictor scale was one of the first things I iterated on, and I had a hunch even in the wireframing stage that a linear scale would work best. Radial displays are typically used to indicate progress and don’t make it easy to indicate one specific point on them if the entire ring is the same color. <strong>When it’s entirely filled in with the same color, the implied 0% and 100% points on a radial scale can be different</strong> for users who are familiar with the mental model of a clock and for users who are familiar with a mental model of a unit circle (from trigonometry). So I stuck with the linear scale and tried variations of it there.</p><p>As I tried to incorporate LinkedIn’s brand colors on the scale, it quickly became clear to me that if the bar was a solid blue color, it would immediately blend in and get lost with the other brand elements on screen, especially the blue header and the large primary buttons. Gradients, despite not being used heavily in the LinkedIn brand, <strong>differentiate this scale just enough from the other solid blocky elements in the app to ensure it stands out</strong> while still retaining a sense of brand familiarity. It transitions between existing blue and green colors from LinkedIn’s brand palette and evokes a unique visual appeal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/862/1*e0XlXzUu-IFpUxG8e83b0g.png" /><figcaption>The scale would always be accompanied by text indicating the satisfaction likelihood</figcaption></figure><p>User testing revealed that users didn’t seem to care much for whether an explicit percentage was shown or an abstract descriptor of where they matched up. So I decided to go with discrete buckets where the <strong>scale was split into five sections</strong>: very low, fairly low, average, fairly high, and very high. There <strong>wouldn’t be any visual indication of where these breakpoints actually are</strong> for the sake of simplicity and to keep the scale feeling more continuous and dynamic. It doesn’t make any difference to a user whether they’re closer or farther away from one bucket to another, it only matters what their prediction level is roughly at for that one specific job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T9-TZMSZTMSXE1f2vp-2tw.png" /></figure><h4>Iconography</h4><p>I wanted to keep the iconography extremely simple by only using <strong>line icons that scale well, are legible at small sizes, and are immediately recognizable</strong> in what they represent. Using these as a guideline, I created a set of ten icons to use as a base for this concept. The Satisfaction Predictor can scale to accommodate far more, but this base set establishes the style and feel of the remaining icons. They use few very lines, have a consistent stroke width on all of them, and work in a single color.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*751Nn9y5A4Y-llBl1AZeqA.png" /><figcaption>The initial set of ten icons, with the filled-in inverted versions serving as the selected state</figcaption></figure><p>Once the icons were made, I used circular outlines as buttons. <strong>LinkedIn’s core shapes involve a circle and a rectangle</strong>, and in order to make this the Satisfaction Predictor icons feel slightly more special, it only felt appropriate to use circles in an app otherwise dominated by rectangular buttons. Once I filled these in using LinkedIn’s brand color, something felt off. They were too bland and <strong>got lost in the screens that were dominated by the LinkedIn Blue</strong> (#0073B1). It was clear that these needed a bit of extra visual flair, and turns out that using another combination of a very subtle gradient in LinkedIn’s primary and secondary blues did the trick.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*bSQ-WU4ZSl4DMmE58A8YTQ.png" /><figcaption>The final set of ten icons with the new gradient applied on the fills and strokes</figcaption></figure><p>The gradient gave the icons<strong> just enough visual interest to stand out a bit more from the rest of the LinkedIn app</strong>. It made them feel slightly more branded to the Satisfaction Predictor, which was now starting to establish its style in the app with its usage of gradients.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fnbxmyBxLDq1BWYNzDsB9A.png" /><figcaption>The final screens with the completed icons and styling. The “My Network” screen (left) shows the icons at the small size along with the Satisfaction Predictor scale. The Satisfaction Predictor screen (middle) and its scrolled up state (right) show how the rounded icons differentiate themselves from LinkedIn’s solid blue buttons.</figcaption></figure><p>The circular buttons work well <strong>without clashing with the FAB (Floating Action Button) </strong>on certain screens, and the gradient really sets them apart from the rest of the app. For branding the Satisfaction Predictor, I paired the name of the concept with the LinkedIn logo in order to establish a sense of brand identity when in the fullscreen modal. Even though the user is still in the LinkedIn app, they’re in a focused flow through this experience, so reinforcing the LinkedIn brand here helps with continually establishing trust.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K4hATJIOEfrlapuQ6_CsAw.png" /><figcaption>The icons appear in the smallest sizes on the jobs lists, where one satisfaction option is listed under the job if you and a high enough portion of the employees who work there have also chosen it in the survey. Even here, the icons are legible and recognizable while also fitting into existing patterns for description text in the jobs.</figcaption></figure><p>Throughout this process, I was <strong>constantly previewing the visual iterations in the screens</strong> to test whether they fit LinkedIn’s brand or not. Did it feel like a part of the app? Did it feel like it was too different? This was a particularly fun challenge to work through, as I <strong>intentionally wanted a little bit of visual differentiation for the Satisfation Predictor</strong> to make it stand out from the rest of LinkedIn, but not to the point that it would feel out of place.</p><h4>Color Palette</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*VA2OuNWSGPj3vW9p9TiafA.png" /><figcaption>The final color palette being used in the mockups</figcaption></figure><p>The two gradients were the only new new color elements I had introduced. Everything else was using LinkedIn’s brand blues. Despite LinkedIn having recently undergone a <a href="https://brand.linkedin.com/">full rebranding</a> with a new color palette that’s warmer and more accessible, I noticed that the mobile apps hadn’t been updated yet to incorporate these elements. Because I was working within the constraints of the existing app, I had to try and <strong>match my designs to the old color palette</strong>. The blues being used for both the gradients are pulling from various blues seen in LinkedIn’s old color palette that worked well for my use case.</p><h4>Typography &amp; UI Elements</h4><p>Despite LinkedIn having its own font (Community), native iOS practices dictate that it is <strong>best to use the system font in order for the scaling and accessibility options to work correctly</strong>. So I stuck with SF Pro Text in the Regular and Semibold variants to establish a simple typographic ruleset that could be used in the designs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VmIaVJa4sPghHdC2NYzm0w.png" /><figcaption>Using the default native OS font for an iPhone app for accessibility and scaling benefits</figcaption></figure><p>For the UI elements, I replicated much of LinkedIn’s styling and usage of CTAs, cards, and other mobile design elements as best as I could. I referenced a lot of the existing iOS app to estimate the usage guidelines for UI components and created any additional interface assets as needed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fD3zVZI_fpnzUXnnIg7Y0A.png" /><figcaption>All the primarily used design components for the Satisfaction Predictor concept that I created</figcaption></figure><h4>Consistently using a visual language</h4><p>Now that the visual styles were established and I had all the design components, it was time to start directly using them in other parts of the app where the entry points to the Satisfaction Predictor were. The designs evolved throughout the process in response to feedback from user testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lppwJ7u2o9lFmhhtNBX0KQ.png" /><figcaption>The swipable short interaction to provide feedback that I originally had in the Jobs tab made its way into the Home feed. If the user responds with a thumbs up on the first question (left), they are presented with the satisfaction options inline immediately (middle), where they can make choices and hit a confirm button. The feedback then shows up informing them how their responses will be used, with a “Learn more” CTA (right) that triggers the Satisfaction Predictor modal.</figcaption></figure><p>The feed was an interesting place to experiment with for an entry point to the Satisfaction Predictor, because it is such a content heavy and noisy screen. There are lots of elements trying to grab the user’s attention here, so the design had to be very intentionally incorporated to <strong>stand out from the cards, not look like a sponsored ad, and still be informative</strong> about its purpose while not taking up too much screen real estate. The most intuitive concept was to not style the questions as a card at all but instead simply overlay the survey questions on the gray screen background, which made it stand out quite a bit from the white cards with black text on them in the feed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m_5Ul20qpO3CVUWcajKjvQ.png" /><figcaption>The entry point to the Satisfaction Predictor flow from the Home Feed (right) follows the same pattern that LinkedIn currently uses to gather feedback on job relevance (left) on the Jobs screen</figcaption></figure><p>Existing patterns were leveraged from the LinkedIn app where appropriate, with some slight tweaks to match the Satisfaction Predictor branding. In the embedded feed survey, the line weight on the thumbs up and thumbs down buttons were made consistent, the buttons now used the subtle gradient fill on the lines, and some vertical spacing updates were made so that the content didn’t feel so crammed in the space between the cards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2LyiN_5IK69X7YOC3M9KJg.png" /><figcaption>The existing pattern for a slider (left) was leveraged as best as possible for the Satisfaction Predictor filter range (middle). I initially started with a handle only on the left side of the slider assuming that users wouldn’t want to filter out the highest satisfaction jobs (middle), but user testing revealed that users are simply more familiar to the pattern that allowed you to control both ends of a filter scale, so the designs were updated to be more intuitive (right).</figcaption></figure><p>The Jobs screen had this interesting interaction where you could filter out jobs with a low Satisfaction Predictor score. For the visual design of this, I used the existing slider base from the Jobs filtering screen, but there were some obvious differences: the scale for the Satisfaction Predictor was <strong>continuous instead of discrete</strong> (an intentional choice to obscure the breakpoints), the ends had a smaller border radius to fit better with the usage of the scale within cards (for better visual harmony), and the fill was using the new gradient styling instead of the solid blue (for feature differentiation). The graph visual didn’t change much from the wireframing stage. Despite it being discrete bars on a continuous scale, it was still <strong>abstracted enough that users didn’t seem to be reading into it too much</strong>, so it stayed pretty much the same way through the whole process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rnyPcMcy_OYvbUtIdQ-HqA.png" /><figcaption>The final Jobs screen, with the initial state of the Satisfaction Predictor prompt that informed passive candidates about the feature (left), prompting them to trigger the “Tell me more” CTA that brought up the Satisfaction Predictor modal (middle), and the final state that allows the user to filter jobs by the Satisfaction Predictor score (right). Users can manipulate both handles of the slider to refresh the list of jobs (limited to two on the card).</figcaption></figure><h4>Copywriting</h4><p>A quick note on the copy in the designs, as they changed quite a bit through the process. Copywriting is an often neglected aspect of the design process, with a lot of designers using placeholder text and leaving the copywriting until the end to figure it out. This is a misstep in many ways. <strong>The design needs to be tested with real copy through every stage of the process </strong>to validate user comprehension of the feature. Designers aren’t typically trained in copywriting and can get a little too focused on the visual presentation of the information rather than actually paying attention to the content of it, but it’s a skill that can be honed with enough practice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fzCYwdxvyGbbV3oXUal9lQ.png" /><figcaption>I rewrote the copy for the “How it works” section in the Satisfaction Predictor scale multiple times based on what users did and didn’t understand when they read it. Here’s a sample of its evolution from the wireframing stage (V1) to the visual design stage (V2) to the prototyping stage (V3).</figcaption></figure><p>A common example of how important copywriting is the repeated instances of the phrases that explain that user responses on the surveys are private and won’t be shared with their employer. These show up everywhere in my designs. In my user testing, <strong>users wanted confirmation that their data won’t be shared with their own employer </strong>at every stage of the process for every question they answered, leading me to repeat the “Your feedback is private…” phrase multiple times everywhere that the Satisfaction Predictor showed up. It built a lot of trust in the platform to have that copy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hgK9r8nP7PRDBKnnPtARFg.png" /><figcaption>Another example of the evolution of copywriting throughout the process. On the suggested company card in the “My Network” tab, users were often left confused about what the percentage meant (V1), so I tried to clarify it as best as possible (V2) and then condensed it down to ensure that the information fits on one line and the card doesn’t get too long (V3). The third version did quite well in user testing, so that’s what made it into the final mockups.</figcaption></figure><p>Another good example is the explicit company name. In many of the mockups, I was testing with copy that said “…your company” without directly mentioning the user’s current company. This <strong>caused some confusion because there were some users that were employed at multiple jobs</strong> (part-time, contract, or freelance) who were confused about which “company” the copy was referring to. So in the final mockups, I got very explicit by specifying the company by name in the designs. This goes to show the importance of validating copywriting assumptions through user testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AfSrv30BAHTYPp5Ha6BVxw.png" /><figcaption>More testing revealed a lot of gaps in the copywriting and overall improved user comprehension of the concept. Seeing reactions to the stylized visuals was also very informative in iterating on them further.</figcaption></figure><h3>Prototyping</h3><p>This is typically my favorite part of the design process. At this stage, the concept has been validated, the design has been finalized, and the UX is in a solid state. Bringing one flow in the concept to a <strong>very high degree of fidelity allows for realistic reactions from users when testing</strong>, especially when the thing is interactive and can be used on their own device. I chose to animate the flow from the Jobs screen to going in to the Satisfaction Predictor modal to properly demonstrate the interaction of swiping and scrolling into the modal, full with realistic animations. The final prototype can be seen below.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F386110464%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F386110464&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F848513495_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1802" height="1440" frameborder="0" scrolling="no"><a href="https://medium.com/media/99801dfe5c2776f4e9369b14c3d36baf/href">https://medium.com/media/99801dfe5c2776f4e9369b14c3d36baf/href</a></iframe><p>If you’d like to play with it yourself, you can <a href="http://akhildakinedi.com/LinkedIn_PassiveCandidateCaseStudy_AkhilDakinedi.zip"><strong>download the interactive prototype from this link</strong></a> (MacOS only, no special software required). Clicking the link will download a .zip file, which you can extract and run on your device. Your browser might warn you about the unknown file, but you can get around it by choosing to keep the download.</p><p>I chose to prototype this in <a href="https://principleformac.com/">Principle</a> because it allows for a lot of custom control in animation and timing. It directly imports files from Figma and allows for easy updating and tweaking of the prototype as changes are made to the designs. It’s a simple tool that I frequently use to demonstrate the final feel of the product and often use it for user testing, as the prototypes can be previewed directly on a device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rAoYCOqdPbnWVn6QyldFkA.png" /><figcaption>A quick peek at what it takes to plan and prep a complex user-driven interaction like the one in this prototype. My Figma layer structure (left) and the rough planning sketch before I began prototyping (right).</figcaption></figure><p>Prototyping is 80% ensuring that the file is setup correctly for interactive animation, 5% hooking up hotspots to trigger the right events, and 15% polishing the timings and easing curves. All the layers have to be grouped, ordered, and named appropriately. All the visibility and positioning has to be just right so that they can be easily manipulated in the prototyping tool. And finally, there’s quite a bit of prep work by sketching out values that need to be animated to and from in the same artboard, so it can be a bit of trial-and-error until I get it to look and feel exactly the way I want it to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8PIGCM2sYA7g3CBUOUXkPQ.png" /><figcaption>Principle allows for lots of custom animation control with offset delays and precise timing</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F386631789%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F386631789&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2Fdefault_1280&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1080" frameborder="0" scrolling="no"><a href="https://medium.com/media/96f611a1c3165a6a9696ba8ec4eb0ce7/href">https://medium.com/media/96f611a1c3165a6a9696ba8ec4eb0ce7/href</a></iframe><h3>User testing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1-sboXz14gnkV4-TSFQn3w.png" /><figcaption>The designs were tested at every stage of the process to ensure that I could make the most out of the assumptions and learnings being made in that phase.</figcaption></figure><p>Although I’m putting user testing in its own section at the end, the designs were regularly tested after the first wireframing stage, in the visual design stage, and one final time with the interactive prototype. It was very informal and unstructured, with me handing the participants (usually friends &amp; family who I knew were passive candidates) a phone with the mockups or the prototype and asking them to talk out loud as they used it. <strong>Testing my assumptions at every stage of the process cleared up many points of confusion </strong>in the concept. The key learnings throughout the process were:</p><ul><li>Users constantly wanted <strong>confirmation that their responses would not be shared with their employer</strong> every time they saw anything to do with rating satisfaction levels, which led to me adding copy clarifying that their feedback was private and wouldn’t be shared with their employer</li><li>Everyone fared better in comprehension when the satisfaction ratings explicitly said “<strong>X% of surveyed employees said this about the company</strong>” as opposed to any other form of simplified copy that I tried</li><li>The users wanted an in-depth <strong>explanation of how the system worked</strong> behind the scenes, which led to me adding the “How it works” section in the Satisfaction Predictor</li><li>No-one seemed to have a strong opinion on whether the satisfaction predictor indicators specified an exact percentage match (ex: 92% match) or if it was arbitrary enough to say “very high”, which led to me favoring the abstracted text version in order to <strong>not let users get too bogged down by minute differences in match percentages</strong></li><li>All users noticed the satisfaction scale on the Network and Jobs screens wherever it showed up and <strong>remarked that they’d find it useful if it “worked as explained” by matching satisfaction ratings</strong>, but there was still a healthy amount of skepticism in its accuracy</li><li>Some noted the <strong>difference between between satisfied at a company versus being satisfied at a job</strong>, and how tightly coupled the two can that it could bias their own ratings (and the ones shown to them)</li></ul><h3>Refining</h3><p>At this point, I’d typically refine and iterate on the designs based on the learnings, but it was a good stopping point due to the scope and time constraints of this project. Overall, I’m quite satisfied with what I ended up with. The general sense I got from the user tests is that they understood what the Satisfaction Predictor was, what its purpose was, and what was in it for them if they took the survey. They <strong>wanted more clarification about the deeper mechanics behind the concept</strong>. How was it weighting the satisfaction responses? Was there a verification or validation system? Could users just game it or break the system by co-ordinating their efforts? I would love to explore these questions and how to solve the new problems that come up in the process of working through them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Be-km606KRdqaYnTF5KP-A.png" /><figcaption>The final design for the Satisfaction Predictor (middle) and the relevant recommendations on the My Network screen (left) and the Jobs screen (right).</figcaption></figure><h4>Next steps</h4><p>Because this project was so tightly scoped into one specific problem and I constrained my thinking to only work within the LinkedIn mobile app, there were many considerations that I didn’t get to lay out or explore in-depth. These ideas came up as I was working through the process and I’d love to tackle them as next steps:</p><ul><li><strong>Directly tying the satisfaction information into a company’s page</strong> so that prospective candidates can get a sense of what current employees have to say about working there (while trying to elegantly deal with any data privacy concerns that come up)</li><li><strong>Exploring emails and mobile push notifications as further entry points</strong> to get passive candidates into the app in order to take the satisfaction survey</li><li><strong>Work the satisfaction scale into more parts of LinkedIn</strong> to build user familiarity with the feature and get more data powering the engine so that recommendations are as accurate as they can be</li></ul><h3>Conclusion</h3><p>This entire process, from start to finish, was <strong>completed in less than five days</strong> (along with writing this post). I spent a long time in the Understand and Define phases making sure that I was solving the right problem. It’s too easy to go straight to pixels and design something that looks incredibly appealing that solves the wrong problem or worse, doesn’t solve any problem at all. The only way I’ve been successful as a designer in my career so far has been to <strong>methodically work through every stage of the process</strong> and ensure I spend the right amount of time in it before moving on. It results in an end product that has been vetted and validated by many different means.</p><p>Thanks for reading if you made it all the way here! I tend to do a lot of writing <a href="https://medium.com/@a_kill_">about the design process</a>, so if you’re curious, I’ve got many other stories for further reading that go into a lot more detail in longer projects. I would love to hear any feedback or thoughts you have about this post or answer any questions. Please feel free to leave a response below or shoot me an email directly to <a href="mailto:dakinedi@gmail.com">dakinedi@gmail.com</a>. I’d love to hear from you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce39d0e6bf6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redesigning a shared inbox for sales teams — a UX case study]]></title>
            <link>https://uxdesign.cc/drift-conversations-redesigning-a-shared-inbox-for-sales-teams-a29120554dbc?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/a29120554dbc</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[redesign]]></category>
            <category><![CDATA[case-study]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Sun, 13 Oct 2019 16:37:33 GMT</pubDate>
            <atom:updated>2020-02-08T02:27:30.923Z</atom:updated>
            <content:encoded><![CDATA[<h3>Redesigning a shared inbox for sales teams — a UX case study</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XWVVaE0EZ5tSoNURGAjeJg.png" /></figure><p>We know product redesigns can be incredibly tricky. It’s tough to get buy-in, it’s tough to figure out what to change and what to not touch, and getting them built out correctly requires a lot of patience and blind faith. Even if all that happens and even if all your design decisions were well-intentioned and heavily backed up by research, it’s a gamble as to how users will react to it. It can be quite a whirlwind of emotions and stumbles, so let’s walk through it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dRFZPEXp_WIOVPAoyouBgA.png" /><figcaption>You’re probably familiar with Drift’s chatbots, shown here on the websites of some of our clients: <a href="https://www.onshape.com/">Onshape</a> (left), <a href="https://www.invisionapp.com/">InVision</a> (middle), and <a href="https://www.onepeloton.com/">Peloton</a> (right). The designs I’m going to walk through are the other side of this story: the view where all these conversations are displayed to the salespeople you’re chatting with.</figcaption></figure><p>I joined <a href="https://www.drift.com">Drift</a> one year ago, and have had the opportunity to lead a major redesign effort for the core interface in the product, the view where all Drift users respond to leads and manage all the conversations happening on their website. It’s no easy task, because everything is updating in real-time and things are constantly moving around in the view as a result of other humans and bots taking actions on them. It was quite the challenge to come up with ways to improve and simplify the experience. The rest of this post walks through our stumbles, pitfalls, and successes during this process.</p><h3>The product and the problem</h3><p>I’m going to walk through how we redesigned Drift’s core conversational marketing platform and overhauled it to be more effective for sales teams. Drift’s primary product line involves a highly customizable chatbot that you can install on your site. Most chatbots out there focus on customer service and support, but Drift offers tools purpose-built for sales teams. When you’ve got hundreds of customers coming to your website and asking questions, there’s a good chance that a few of them are solid leads. Based on how the bot qualifies these leads, these conversations can be sent to specific sales reps or account managers where they can jump into the chatbot conversation and continue talking to the customer, human to human.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*chv_-FHnZ8K2it0HkRwsxg.png" /><figcaption>This was the state of Drift’s Conversations view when I joined the team. Right off the bat, you can tell that the view is trying to do way too much and that there isn’t much visual consistency or hierarchy to the information architecture and layout of the screen. My first step was to address this right away.</figcaption></figure><p>This is where the product I lead design efforts for, Drift’s Conversations view, comes in. When you’ve got a massive sales team managing hundreds of conversations on your site at any given time, it can get a bit chaotic. There’s a mixture of support and sales conversations, there’s dead leads that don’t respond, there’s sales reps jumping into each others’ conversations trying to claim the lead for themselves, and there’s a lot of general confusion as to what the state of things are on your website at any given time.</p><p>So when I started at Drift in September 2018, I was tasked with leveling-up this view (note: this is a web app that runs in a browser). I needed to solve the most pressing usability problems in the view, modernize its interface and clean it up a bit, and envision what the future of this view would look like based on where the product is going. All as quickly as I could. No pressure.</p><h4>What’s so special about this?</h4><p>Before diving in, I’d like to address what’s different this time around. I’ve <a href="https://blog.prototypr.io/product-redesign-case-study-evolving-a-mobile-web-browser-73fdd4e04dae">written about major product redesigns</a> before and have gone through the process a handful of times. But this one felt different. The product itself isn’t in a category that’s terribly difficult or novel to design for. It’s messaging. It’s a large shared inbox. There’s plenty of role models to choose from and lots of established design patterns to get inspiration from. So why did things feel that much more challenging and so much more difficult this time around? It comes down to a couple of things:</p><ol><li>I was now <strong>designing for one single view</strong> that had to contextually scale and handle over sixty or seventy different things, all of which were updating in real-time based on the actions of your teammates, the customers you’re talking to, and bots automating tasks as you’re working in the view. This is very different than say, a mobile app or a video game where you can layer and nest the menus or options across different screens and pages. This entire product was just one view, and I had to use this as a strict constraint when designing.</li><li>I was <strong>designing for people whose livelihood depended on using the product well</strong>. This wasn’t just another consumer app free to download on the App Store or a free-to-play game. This was a product people were paying thousands of dollars per month for, and their performance at work was measured by how effectively they could use our product. Throwing major redesigns at people just trying to do their job can backfire dramatically, so this needed to be handled carefully with a lot of empathy for our users who relied on our product for their work.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5fe-5-a0_rjW-xV8Kr3YgA.png" /><figcaption>An example of a very early user workflow map I made in my first couple of months at Drift by shadowing a sales rep for a few hours. I needed to understand how this view that I was designing for fit in context of the user’s daily workflow: what they did before, what they did after, and how they used it in conjunction with other tools. Diagrams like these were instrumental in shaping my design thinking throughout the process to spot breakpoints in the experience.</figcaption></figure><p>These were challenges that I never had to deal with before in my design career, so it was a mix of excitement and nervousness. I was ready to tackle it, but I knew so little about industry and the users that I needed quite a bit of ramping up before I got to a point where I felt comfortable knowing what I was doing. It certainly helped that Drift’s culture tends to be one that takes big swings and is all in for you taking big risks and being completely okay with failing at them, because you’d at least have some major learnings from the failures instead of learning absolutely nothing from small incremental updates that fail to garner any sort of reaction from the user base.</p><h3>Part I: Getting to work</h3><p>So let’s get into it. This product, internally referred to as the “inbox” or the “convo view”, was not getting a lot of love. Many different product teams had cobbled together features to live in this view based on sporadic customer feedback over the years and as a result, the view had accumulated a good chunk of design debt. There had never been an overall vision or a thoughtful structure to the thing. It was starting to feel clunky, outdated, and very buggy. This is the piece of the product that customers used most frequently, so it was frustrating to everyone that it just didn’t feel good to use. Everyone wanted it to be good, and only around when I joined the team had the company gotten around to properly resourcing a full team to manage and overhaul the conversation management experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*chv_-FHnZ8K2it0HkRwsxg.png" /><figcaption>Here’s the view again in its state when I joined the team. Beyond the visual and IA issues, there were a lot of usability problems in the view. It was difficult to keep track of conversations and it wasn’t clear what needed your attention at what times. I knew there was a lot of work ahead of us.</figcaption></figure><p>Naturally, I asked a lot of questions to have some design constraints that could guide my ideation and thinking. I asked sales reps who used the product, customer success representatives who onboarded people into using the view, and the product leaders about what it needed to do. I walked away with a sense that it needed to do a lot of things:</p><ul><li>Let users <strong>manage their own conversations</strong> while also allowing sales team admins to <strong>monitor all conversations</strong> on the site</li><li>Scale across different <strong>sales teams</strong>, <strong>connected apps</strong>, and <strong>multiple orgs</strong></li><li>Allow users to easily <strong>search and find </strong>old conversations on the site</li><li>Clearly <strong>notify and alert</strong> users when important accounts are on their site</li><li>Work in conjunction with our <strong>email product </strong>offerings</li></ul><p>That’s a lot of work for one view. And that’s just the primary goals. It gets crazier once you get into the details of qualifying leads in a specific conversation, but more on that later.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F365985578%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F365985578&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F821881705_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1054" frameborder="0" scrolling="no"><a href="https://medium.com/media/f80a71f700e757e244d5925ba4c1f553/href">https://medium.com/media/f80a71f700e757e244d5925ba4c1f553/href</a></iframe><p>So my first attempt was a shot at organizing the layout in a way that handled all these things I had just learned about. I added all the features people asked for into the view and tried my best to keep it manageable by making panels collapsible so that irrelevant information can be hidden when it wasn’t necessary. It worked in theory, but it made a lot of people realize that this was starting to get even more confusing with a lot of things on-screen. We could solve some of the confusion through copy and UI clarity, but it got people asking whether we’re asking too much of the view or not. Even I started to feel that this was a little overwhelming because I was cluttering up the view with lots of buttons to <em>hide</em> information from the view. As a designer, that’s when you know there’s a problem.</p><p>This, to me, is one of the best things you can contribute as a designer to a product company. Many managers, leaders, and strategists have a high-level overall vision of what they’d like the product to ideally do, but have a hard time visualizing what that would look like in an interface and what the experience of using it would be. If you’re able to put together something quick to give them even the slightest idea of what we’ll end up with, you can quickly pivot on some of the potentially controversial product assumptions.</p><h4>Some design feedback</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u84oT4Xik80MQlfrlr_g4A.png" /><figcaption><a href="https://www.intercom.com/inbox">Intercom Inbox</a> (left) and <a href="https://frontapp.com/">Front App</a> (right) utilize a large “filter panel” on the left of their primary view. This panel does a lot of work by being the place for many different actions along with content for navigation, switching modes, settings, accounts, and links to other parts of the product where necessary.</figcaption></figure><p>While I was living in concept land trying to make something work in the view, my fellow designers at Drift had some great pieces of feedback. Just before I had started, they had already done a lot of research on this problem of handling multiple types of content and information in the view. Many other web apps that feature large shared inboxes have solved the inbox management issue by utilizing a “filter panel” on the left side. This functioned as a master control for the whole view, allowing users to quickly switch between different preset filters and find what they needed.</p><p>I already had something similar in my original concept, so I decided to double down on it even further and clean up the UI a bit, making it match a little more closely to what the other web apps do. Additionally, we decided around this time to not worry about some of the more complex tasks we were asking of the view, like scaling across teams, apps, orgs, and working with the email product. We needed to nail the core experience first, and that just wouldn’t be possible if we were trying to do too many things at once.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F365990056%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F365990056&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F821887218_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1077" frameborder="0" scrolling="no"><a href="https://medium.com/media/6744002d433b8b0d15db41924491c9d6/href">https://medium.com/media/6744002d433b8b0d15db41924491c9d6/href</a></iframe><p>This time around, I simplified a lot of things. I put a lot more thought into the layout of the interface and wanted to pay closer attention to things like information hierarchy and type styles. It needed to feel fluid, fast, and responsive. Static mocks might be great to convey the idea, but this is a view that’s handling a lot of live data, so little micro-animations and transitions were crucial in conveying the usability of the view here.</p><p>This was starting to feel a lot better. The view felt nicer and cleaned up, and the experience started to feel a little more elegant. In user testing, the filter panel seemed to be looking very promising as a solution to the usability issues of the view, as most people seemed to love the idea and were already familiar with the pattern. So we set out to build it in the existing view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-MtbXOSu0pm1kBtyCYiCwA.png" /><figcaption>Here’s what the built version of the filter panel in our view looked like. We kept it dead simple to start with in order to validate the usability first before going too deep with visual changes. A light drop shadow and a faded background color helped add some depth to separate this panel from the list of conversations.</figcaption></figure><p>As a team, we had grand plans on how to scale up this filter panel from this first version up to a more robust and flexible one based on user feedback and lots of internal beta testing. Our product manager had a full roadmap, milestones, and timelines of when we could release it to all our customers. It helped that everyone at Drift also used the Conversations view to chat with customers on a regular basis, so we expected it to be easy to get feedback and keep building. But…things didn’t exactly go according to plan.</p><p>As we put this out to more and more users (just internally), it became clear that the product wasn’t conveying the fact that it had gotten simpler to use. We were introducing yet another panel in the view (on top of the existing three) and proclaiming that it’s easier to use because there’s now more buttons to click on and more panels to manage by expanding or collapsing them. Doesn’t exactly instill a lot of confidence in simplifying the view now, does it? But in terms of usability, we actually were getting positive feedback. Users found it easy to switch between just their conversations and all conversations. They were able to find what they needed and quickly take actions. And yet, the overall view was getting more cumbersome to look at with the addition of a fourth panel, so we scrapped the idea before going too much further with it. The loss in visual clarity was too much compared to the usability benefits of this filter panel, so it died before it had a chance to shine.</p><p>In hindsight, I’m still not sure if this was the best move. We had built something that was solving a real problem, and it seemed to be working. There was a lot more we could’ve done to simplify it and educate users on best practices, but we didn’t have the trust of our users to keep pushing something that so obviously seemed like it was headed down the wrong path, so the idea was killed off. Who knows what would’ve happened if we stuck to our guns and pushed through one or two more iterations based on user feedback? We may have solved it, but we can’t say for sure. It’s a bit like putting a low-fidelity movie trailer in front of a focus group to gauge their reaction and deciding to not pursue the film due to it failing to make an impact.</p><h3>Part II: A pivot to remember</h3><p>Soon after we killed the filter panel, we got together in a room with our CTO and VP of Product to talk about exactly what we should be doing with this view, because clearly, our team needed some guidance on how to properly approach a project as large as this. They stressed the importance of using a strong role model to build upon: we were working off of role models like Intercom and Front App, but we should have been working off of Slack. Slack uses a sidebar and a detail view as a constant throughout their entire application. This design constraint, intentional or not, forces them to make everything work in a simple layout without too much cognitive load.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UXpVrq6HJBy6YcEpegbE9A.png" /><figcaption>Slack’s view manages to communicate a sense of simplicity and ease-of-use by keeping a consistent design paradigm of one dark left panel and one main message window across its entire interface.</figcaption></figure><p>I walked out of that room feeling like I had a much better sense of what the view needed to do. It needed to be dead simple, comprehensible at first glance, and always had users in a state where they knew exactly what they needed to do next. And this time, we knew we had a strong role model in Slack. The product goals do not map one-to-one: Slack is inter-team communication whereas our product was geared around communicating with anonymous strangers interacting with a bot on your website. But the takeaway was that we needed the product to feel as simple and easy to use as Slack. It couldn’t have complex interaction models of managing conversations and chatting with customers. It needed to be intuitive and obvious. My goal now was to push this product towards a more streamlined, Slack-like view.</p><h4>The concept</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O5ATuRHlJ83vFeLX9kh2RA.png" /><figcaption>My Slack “inspired” design for what Drift Conversations could look like. In the interest of keeping familiar patterns and consistency for users, I kept as much as I could as close to Slack’s design as possible. This concept sparked a lot of conversation and debate within the team about whether or not to pursue this approach.</figcaption></figure><p>And so I made…a Slack clone. No joke, it looked exactly like Slack. A dark sidebar on the left and a detail view on the right. I talked to a lot of salespeople to figure out the best way to layer all the information we could possibly display on the views here. They wanted to see specific details about the customer, a full history of the account in one conversation, every point of contact they’ve ever had with the person they’re talking to, and much more.</p><p>This single design was more eye-opening to the team than any of my earlier concepts. While the previous designs were trying to simply clean up the interface or organize the existing features more effectively, this view completely re-invented what the view was and how it worked. You now didn’t have buttons splattered all over the view to manage conversation status, participants, or tags. The main interaction simply revolved around clicking around different conversations on the left and chatting with customers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G9ikljsNBPOapiqVwvG_Hw.png" /><figcaption>My design concept for how “channels” would translate into our view. Heavily inspired by Slack’s “All Threads” view, an account channel lists out all conversations with customers associated with that account. Users would be able to click into individual conversations to view it in detail, just like any other conversation.</figcaption></figure><p>Another revolutionary idea that came out of these conceptual designs were the notion of channels. Again, taken straight from Slack and adapted to our system, channels were proposed as a loose definition of a “collection of conversations”. So many sales teams wanted a historical log of every account within Drift, so it only made sense that we offer a solution for this. The idea was that every account would have its own channel, and you would also be able to create channels for specific sales teams. Individual sales reps could pin and star specific channels that they’re interested in, which would stick their important accounts to their sidebar while they keep having conversations with new leads at the same time.</p><p>As you can imagine, creating something like this is no easy task. Nothing in our backend infrastructure was setup in a way to allow for or create this, and even if we did make it, it wouldn’t quite work reliably in the way that users would expect it to. Moreover, the team wasn’t really sold on this idea (myself included). Channels work for Slack because it’s a static group of people you’re familiar with. Channels serve as a hub of communication around a specific topic. It really doesn’t translate well to a system where lots of anonymous users can start blowing up an individual salesperson’s inbox with hundreds of conversations. So due to a lot of open questions and confusion around channels, we set it aside as a thing to figure out and eventually get around to after nailing the core experience of responding to individual conversations.</p><h4>The build</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z96D_5MFOMk7HF814dUdEA.png" /><figcaption>We already had our existing filter panel built, and we needed to start building this Slack-like view. So we decided to simply build upon the filter panel that we had (left) and Slack-ify its visual design a bit while adding all the new features we needed from the design concepts I had for the first milestone (right).</figcaption></figure><p>And then we got building. Everything I had so far were just pretty mockups. We needed to build this out and actually test it with users, so we got to work scaling up our existing filter panel to adapt to a Slack-like sidebar that I had in the concepts. We would essentially be merging our conversation list with the filter panel and just have one sidebar.</p><p>We also made a very controversial decision around this time, which is to only test this as an internal private beta and keep it under the radar until it was complete. We wouldn’t be testing with external customers and would not let the world know about this until it was complete. I questioned this choice at the time and was a little nervous about not getting feedback from external users before committing to major design decisions, but went along with it because it would mean that we could flesh it out completely instead of shipping half-baked versions to customers like any other iterative launch. So we recruited some internal sales reps and got to work building out the view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*71QcGtHW_y_jSs-61c68Qw.png" /><figcaption>This was our live build of the Slack-like sidebar. We didn’t touch the rest of the view and only focused on the sidebar for now. Having counts for unread messages in every conversation was more technically complex than we had anticipated, so this version only had orange squares in its place to indicate unread conversations.</figcaption></figure><p>So we actually built that Slack-like sidebar. And it was quite a treat to see it actually functioning as a real thing. Conversations were coming in, read/unread states were working, and things were re-ordering as necessary. This was the core workflow we needed to nail, and it was great to see it all come together. We were being very scrappy as a team around this time and just trying to validate our assumptions as quickly as possible, so a lot of the old UI was left untouched in favor of first validating the UX.</p><p>Validating design assumptions was a huge challenge to deal with through this whole redesign process. This view was notoriously difficult to test with static mockups and basic clickthrough prototypes. There was a lot of live data and real-time updates happening in the view, which was incredibly time-consuming to prototype effectively. We would never be able to simulate a real-time flow of using the view in a steady state with notifications and live updates working properly. And when we did invest the time to do it, we weren’t getting great results. Users had no investment in the conversations they were seeing and they didn’t reflect the types of questions their own customers would normally ask. So we ended up having to actually <em>build</em> something so that users could test the view with their own conversations on their own account (even if it was just internally) in their own daily workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hEegc9J8qBSxdf9RAqqDLw.png" /><figcaption>The “All Conversations” view in our live build. We were being extremely scrappy here in order to move fast. The design simply expands the existing conversation list to span the full length of the view while displaying the same information it did in the list. We stuck to our design constraint of always having the sidebar visible.</figcaption></figure><p>We ran into an interesting problem when testing this view. Our own internal salespeople use the view in a slightly different way. Our sales team didn’t rely on conversations being automatically routed to them, but instead they “hunted” for leads in the list of all conversations on the site, a workflow we internally termed “prospecting”. We knew we’d need this in order to get the right feedback, so we needed a view that housed all the conversations on the site that could be accessed without losing track of conversations you were already in. Heavily inspired by Slack’s “All Unreads / Threads” views, we added a button on the top that said “All Conversations”, which when clicked swapped the view to an expanded list of all conversations on the site, along with some light sorting and filtering options thrown in for good measure.</p><p>And then we tested it with internal salespeople. And…it didn’t go great. Turns out that this “prospecting” workflow was so heavily relied upon by our internal sales team that they were constantly going to “All Conversations”, clicking into a conversation to get context on the customer’s questions, then going back to “All Conversations”, clicking on another one, and repeating the same process over and over. Occasionally, they’d jump in to a conversation, which would add it to their sidebar, but overall the experience of jumping into and claiming a conversation for themselves was simply not working for them. In the old view, they could simply click into a conversation on the left and start chatting. This became much harder in this Slack-like build because we were now forcing them to click multiple times to take the same action.</p><h4>The learnings</h4><p>So clearly, this wasn’t working out as expected. We could’ve kept iterating and keep on making changes, but here’s the catch: the more time we spent working on this internal stealth-mode private beta, the less time we spend on solving UX issues in the actual view that customers were using on a daily basis. We were a tiny team. The usability complaints in the existing view were racking up and we didn’t have enough resources on our team to handle both projects. We had no idea what our timeline would be to get this Slack-like view out to all customers due to all the unknowns, so we unfortunately had to scrap it and pivot back to solving core issues in the existing view.</p><p>This isn’t to say that it was a complete waste of time. We ideated a lot on things, made visual concepts for a lot of ideas, and even built out a first version of our vision. This failure resulted in a couple of key learnings:</p><ol><li>We <strong>did not properly prioritize workflows</strong> for the people we were testing with. We were laser-focused on solving the experience of receiving and managing conversations, but got so tunnel-visioned by it that we ignored a core workflow that our testers had: prospecting across all conversations.</li><li><strong>Not testing with actual customers was a mistake</strong>. This was an internal-only private beta, and we were sort of operating in “stealth mode”. The feedback we were getting was very specific to one type of extreme power-user workflow, which made it very difficult to scale the experience across all of the use cases. Moreover, the people on our team were all pretty fresh to Drift and didn’t feel comfortable making big decisions without knowing our customers and their usage habits well.</li></ol><p>Another personal learning for me was realizing that when users and people in product say something along the lines of “make it feel as simple as Slack”, they don’t just mean literally copy the UI. They just want it to work as elegantly as Slack, which often requires hefty backend changes under the hood. You can’t simply change what the front-end interface looks like and expect the entire system to magically simplify itself. Our view is like the final frosting on a cake, where many other complex systems are interacting underneath and creating the foundation for it to work. If those bottom few layers of the cake aren’t providing a stable foundation, it doesn’t matter how great the frosting tastes.</p><p>Finally, I learned that designers alone cannot handle sweeping product overhauls like this. There was a lot of pressure on me to come up with a vision of what the view should be and what we should be focusing on. At Drift, designers and product managers are shared across multiple teams, which makes it tough to prioritize big projects like this when you’ve got pressing features and designs to be worked on that are actively blocking the engineers. If you’re ever handling a major product rework, make sure that the team working on it is resourced appropriately and has enough time to fully explore the solution space in order to truly build the right thing.</p><h4>One more thing…</h4><p>Before scrapping all of the work for this Slack-like view, I wanted to do one last round of user testing. We had gotten tons of insights from internal sales reps about <em>exactly </em>what they wanted and didn’t want from the view. So I just listed down all the feedback, stuck to the design constraints I was working with, and tried to mockup a very lightweight version of what that would look like if we were to build it out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kwBE1f8DhAHAtMBnOiFmeQ.png" /><figcaption>My lightweight wireframes for what a prospecting view would look like if we designed it exactly how our users wanted it. I used Slack’s Threads view again as a design reference to showcase the interaction of clicking a conversation and viewing it in a pane on the right before deciding to join it. Users absolutely loved this.</figcaption></figure><p>This was a wireframe view that switched up the entire model of how we displayed conversations. Instead of listing the name and last message, we were now displaying the account name and other crucial information like Salesforce Account Owners, location, and company size (all of which the sales reps asked for). This made it really easy to scan down the list, figure out what accounts you were interested in (or look for ones that didn’t have a SF Account Owner), and only then decide whether it’s worth looking at the context of the conversation. If you did decide to click into it, it would open in a Threads-like view on the right, where you could quickly get context on what the conversation was and jump in if you wanted to.</p><p>Even though these were extremely simplistic wireframes, we got really good feedback on it. The sales reps loved the idea of prospecting so easily and quickly. On the product side, we were wary of taking feedback from just one sales team and investing lots of resources in building a full-on prospecting workflow (which most of our other customers don’t actually do to the extent that our internal sales team does), so we took some valuable nuggets of feedback from this little experiment and saved it for later.</p><h3>Part III: A fresh start</h3><p>Let’s put things in perspective for a second. We failed to ship the filter panel UI improvement due to us using the wrong role model, and we failed to make any meaningful progress on the Slack version of the app due to improper workflow prioritization and a stealth-mode approach. Needless to say, morale in the team wasn’t great around this time. We were questioning why we were failing to function well as a team and what we were doing wrong.</p><p>But our path forward at this point was pretty clear. We need to be solving actual problems in the actual view that customers were using every day, not spending weeks and months tinkering with ideas that had uncertain milestones and lots of unknowns. So we decided to just go heads down for a bit on some things that would make a big UX impact in the existing version.</p><h4>A Compact View</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8JbTk35zJSEYe3ZUNqRSww.png" /><figcaption>Our existing sidebar (left) compared to our first version of a “Compact View” (middle) and our second iteration of it (right). We re-styled the list based on iOS Messages, a familiar paradigm to our users, and added core features back in after testing with users. We also tested an “Unreads Only” mode that would filter the list down to only unread messages as an effort to reduce the noise in the list, but killed it after getting user feedback that it just ended up being more confusing.</figcaption></figure><p>Right off the bat, I noticed that the information density in our existing conversations list was completely inconsistent. Every cell had a variable height depending on how much information we had to display, our tags were styled in visually overwhelming ways, the type styles emphasized the wrong information, and we were displaying tons of irrelevant information in the first place. This absolutely needed to be cleaned up, and I had no idea what information was actually valuable and what wasn’t. So we ran a fun little experiment: kill all the extraneous information in favor of a more compact view, add it as an opt-in toggle to the top of the list, and see what people find themselves opting out of the compact view for. The first version of this removed literally everything from the cells except for read and unread states.</p><p>When we asked users their thoughts on it, it turned out that most users didn’t care much for tags or participant information in the list. Boom. This helped simplify the information so much already. They mentioned, however, that they found the avatars useful as a way of anchoring themselves to a specific conversation (it was too type heavy otherwise). Additionally, they found the CQL scores (the lightning bolts) useful as a way of keeping track of high-intent leads. So we added those back in to the second version (along with more useful location/company indication), and then shipped the new version to all users. Validating the assumptions with a small beta pool first really helped us feel comfortable with our decisions before shipping it to everyone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RVYeXi3DNkN7l10UXQX5Hw.png" /><figcaption>Our initial list of conversations (left) compared to the final version of our “Compact View” that we shipped (right) after testing with a small beta pool. We removed the toggles and shipped the cleaner UI to all customers after validating all our assumptions and adding back in what users found necessary in their workflows.</figcaption></figure><h4>A Split Sidebar</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VXaKMtzGB49R3yimX2y6NQ.png" /><figcaption>Yes, there’s a dropdown up there! Believe it or not, this is how user switched the filters in the list. Users would have to click on the header (left) in order to open a dropdown and switch the applied filter (right).</figcaption></figure><p>One of the biggest usability problems in the existing view was that users had to keep opening a clunky dropdown at the top to switch the list of conversations between a bunch of different preset filters. For prospecting in new conversations, users would hunt around either in the Open filter, the No Participants filter, or the All Conversations filter. Then, to manage just their own conversations, they’d keep going back to the My Conversations filter.</p><p>The problem was that when they were prospecting in the other filters, they would lose track of new messages and important updates in their own conversations, which in turn left customers on their website hanging. I needed to come up with a solution that allowed users to keep track of their own conversations while also allowing them to keep an eye on other conversations that they could jump into whenever needed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n5JGsuA6-4lKneNIf5Ig3A.png" /><figcaption>Some examples of my early ideation for how to alert users about their own conversations while allowing them to view other conversations. I tried a tabbed-layout approach above the conversation list (top-left), tabs for every conversation you’re in above the details window (top-right), the same tabs but at the bottom similar to FB Messenger (bottom-right), and a split out navigation above the conversation list that just exposed all the options in the dropdown (bottom-left).</figcaption></figure><p>I explored quite a few options here, because the solution this time around wasn’t as simple as “kill everything and see what happens”. This was a major workflow change and would be a big effort from the front-end engineering side. So I spent some time ideating various options based on how other inboxes and messaging apps have tackled the problem. I tried exposing the dropdown options, switchable tabs on top laid out horizontally across, and even versions where different conversations would be available in tabs across the top or pinned as chat windows to the bottom.</p><p>All of them seemed promising and people gave some great feedback in user testing, but we would be introducing so much more complexity into the system here with this change. It would be much easier to actually end up losing track of your conversations with any of these options, and notifying or badging specific conversations with unread messages gets even trickier. So I kept doing some more competitive research until I stumbled upon a solution that harkens back to the design constraints of the Slack-like version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_Ppt4tq1N_uZciRuzQNeA.png" /><figcaption><a href="https://discordapp.com/">Discord</a> (left) and <a href="https://www.livechatinc.com">LiveChat</a> (right) split their sidebars into multiple sections to categorize and separate different types of content. They also allow these sections to be collapsible and expandable.</figcaption></figure><p>There were apps out there like <a href="https://discordapp.com/">Discord</a> and <a href="https://www.livechatinc.com">LiveChat</a> that had successfully used Slack as a role model and split up their one single sidebar into a long scrolling list that had different collapsible sections. This was exactly what we were looking for. Slack doesn’t let you collapse the list because your list is mostly static, but for apps like these with dynamic lists of ever-growing content, collapsible sections go a long way in ensuring that important stuff doesn’t keep falling off below the fold. Confident that this was the right solution for our use case, I mocked up what our view would look like with this type of split sidebar where users could keep track of their own conversations on top while prospecting from the list below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vsrf9j578jhGQLAPOWZZCw.png" /><figcaption>The final “split sidebar” that we ended up shipping as part of our public opt-in beta. Users’ open conversations would be in the top section (left) and all other filters would be accessible from a dropdown in the section below (right). We had many workflow concerns around a change like this, so we kept it as an opt-in for now.</figcaption></figure><p>After some visual iteration on what the styling should look like, I had a solid concept that we could build and test. If the user had no active conversations, the top list (“My Open Conversations”) would be empty, and they could click on a conversation from the bottom list to jump into, at which point it would move into the top section. This did cause some concerns amongst the team about conversations jumping between sections all the time, which could throw off users. There was also a chance that conversations would suddenly disappear based on what preset filter you had selected at the bottom.</p><p>Because of all these concerns and our learnings from the past two massive changes that we pushed to the view, we kept this split sidebar gated to an opt-in public beta. Users could try out a new version of the Conversations view, which would put them into this beta with the split sidebar. We also added a way for them to give feedback about the view directly through app, which helped a lot in addressing the main concerns of our users. More on this later!</p><h4>A Northstar vision</h4><p>So we were feeling pretty confident that we had solved the most pressing problems in the view, and that we can keep building upon this idea of the split sidebar. In fact, this sidebar was behaving so elegantly and intuitively that I kept pushing it further to incorporate even more types of information in it in the form of a long, scrollable list with collapsible sections, internally named “slices” of conversations.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F366001237%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F366001237&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F821901006_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1434" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b7561a4660e49bfac6175254fe6862b/href">https://medium.com/media/1b7561a4660e49bfac6175254fe6862b/href</a></iframe><p>We were asking one sidebar to do a lot, but I had some ideas on how to make this work seamlessly. Users would start off with the same two preset slices that we had in the split sidebar, and they could keep adding custom slices below it based on specific conditions. For instance, displaying customers that are online on the website but aren’t actively engaged in conversations is a big one. Targeted accounts that the sales rep has indicated as important can be its own slice entirely. This was meant to scale and handle lots of different types of data over time, so we were building the foundation for it here.</p><p>This was all well and fine, but the product team wanted a better picture of where we were heading long term. Even though we had solved pressing issues in the view, it wasn’t totally clear where we’re going with this product and what the future vision was. The engineers needed to build the infrastructure correctly and we needed to plan our product roadmap ahead of time, as we had been burned in the past by not planning adequately for sudden pivots and a lack of clarity around product and design objectives of any given approach. So in order to paint a better picture of where we were going, I got to work on some “Northstar” vision concepts for the view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gp-9GkyL-lCJLGpqfZUZuw.png" /><figcaption>This was my “Northstar Vision” for the Drift Conversations product. A sidebar on the left that handled many different types of conversations and accounts, and a main view that would swap to the relevant screen while always keeping the sidebar visible. This home dashboard had quite a few ideas kicking around in it, including a way to inform users about actions that they should take right now, new leads that need their attention, and other bot-qualified leads on the site.</figcaption></figure><p>I took a different approach this time around. Instead of asking “how do we fit all the existing features we have into a nicely organized layout?”, I asked “what would I design this view to look like if we weren’t attached to the existing interface and had no technical constraints?”. This obviously led to drastically different results in the ideation phase. Based on all my learnings so far, I organized all of the crucial parts of the sales rep’s workflow into a home dashboard. This would be what they see when they opened Drift every day. It would summarize all of the key events happening on the site and would prompt them to take action on the most immediate things.</p><p>Again, there was a fair bit of asking around actual salespeople to figure this stuff out, because there’s no way I could’ve known all these things myself. Things like meetings booked, lead syncing, information about account owners, and the lead qualification process is all handled very differently from one sales team to another, so it had to be high-level and flexible enough to adapt and accommodate to a specific sales team’s workflow appropriately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hM1lFjwIY9T6pbIIzuGOKg.png" /><figcaption>Some alternative concepts and ideas that I had as part of explorations for the Northstar vision. Metrics on individual and team performance (top-left), a better indication of going online or offline (top-right), a right-click menu to bring up additional actions (bottom-right), and a pop-out prospector view that would trigger by hovering on any user in a specific list that displayed important details about the prospect (bottom-left) were all concepts that I toyed around with in this phase.</figcaption></figure><p>I also took this opportunity to mock up some wilder ideas based on user feedback that could potentially work well with our view. A lot of sales reps wanted to know how they ranked up against their team, so I added a few status and funnel tracking graphs to help salespeople understand how they were doing relative to their peers. The concept of going online or offline had always been a confusing one in our product, so I modeled an idea for a giant “Go online” button following in the steps of popular ride-sharing apps like Uber or Lyft. For the custom slices, I also had the idea of a “pop-out prospector” view, where the user could hover over some of the online visitors and get quick information about them at-a-glance without needing to swap the entire view just to see a few additional details.</p><p>All of these details were great, but they seemed to distract from the overall vision of the Northstar, which was supposed to be simple and focused on one goal. So we scoped out the idea of having a separate home dashboard and all these other tabs and views within it, as well as decided to not get too distracted by the other “nice-to-have” features (like the ones above) before nailing the core of the experience first. Working with my product manager, we condensed the goals of this Northstar down to four simple tenets:</p><ul><li>Smart <strong>in-app notifications</strong> for high-intent leads</li><li><strong>Prioritized alerts</strong> for when Target Accounts are on-site now</li><li><strong>Configurable sidebar</strong> with sliced views of active leads and prospects</li><li>Direct <strong>editing of lead information</strong> right in Drift</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DJD4fGOplf8W8mVFH4FMdg.gif" /><figcaption>I put together this final set of images to showcase exactly what the Northstar vision was all about in order to communicate the goals of this update to the rest of the product teams. The interface here got heavily streamlined to focus on core workflows and everything was prioritized according to these four tenets.</figcaption></figure><p>And there we had it. In terms of the actual interface, the view of a single conversation didn’t really change all that much. I just drew a little more attention to the messages, cleaned up the message composer below, and simplified the contact details on the right side. This final design abided by the simple two-pane layout constraint that we were going for with the Slack-like version of the app, and incorporated many of our learnings and insights from the lightweight prospecting view of the Slack app that we had gotten some feedback on. This final version felt simple, straightforward, and intuitive.</p><p>This really helped rally the team around what we should be building towards. Before the rest of the team saw this, no-one had a clear vision on where the product is heading or what we were actually working up to. Only after showcasing and explaining these conceptual mockups to the team did it become clear how to proceed forward with the rest of our goals and roadmap.</p><h4>Public opt-in beta</h4><p>Now that we knew where we were going, it was time to swing for the fences. We already had a public opt-in beta that users were manually opting into for our split sidebar experiment. We decided to just convert this to a full beta where we would make big changes to the interface and see how people reacted. Our concerns about breaking user workflows were ameliorated by the fact that users could always switch back to the old view if something went wrong or if they weren’t happy with it. We weren’t killing any features and users always had a safety hatch to go back to their old workflows if they didn’t like what they saw in the new view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pFrXOrg4gmTdA0jeUrydyQ.png" /><figcaption>The very first thing we did was to darken the list of conversations in accordance with our Northstar vision. I got rid of all the lines separating the content and gave the headers more definition (left), which we then also simplified once users got used to it (right). We also added “Priority Leads on site” as another slice here to test the waters for whether or not this sidebar would elegantly handle so many different types of content and still behave smoothly.</figcaption></figure><p>The most immediate place to start here was the list of conversations on the left. Thanks to our Northstar vision, we knew we were going to have a sidebar that had to handle many different types of information and would need to have multiple sections that were expandable and collapsible. And we knew it was going to be dark, so I used our existing color palette from our design system on here and essentially dark mode’d the list of conversations. This was the first thing we built, and we kept making UI tweaks to it in order to efficiently fit more information into it, experimenting with even more compact layouts and information density based on what worked and felt right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RwmziKgvY-4CKap1OM-wDQ.png" /><figcaption>Our old Contact Sidebar (left) compared to the cleaned up and redesigned version (right). We removed irrelevant CTAs on the very top that were crowding the view and brought focus to the content within the sidebar, highlighting each card prominently and even allowing it to collapse into a minimized state.</figcaption></figure><p>Another big piece of the view we hadn’t touched yet was the sidebar on the right. This was the “Contact Sidebar”, which provided users with more context on the customer that they were chatting with on the site. An entirely different product team owned this section of the view, so we hadn’t touched this at all. But in the spirit of extreme ownership, we decided to take a big simplification pass at this sidebar and clean it up a bit. We streamlined a lot of the information into cards and added a more sensible hierarchy at the top.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F366078676%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F366078676&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F822008204_640.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="720" height="1114" frameborder="0" scrolling="no"><a href="https://medium.com/media/a9c39de099e6850bebabccfd211d2506/href">https://medium.com/media/a9c39de099e6850bebabccfd211d2506/href</a></iframe><p>I proposed an idea where we would have a minimized version of the sidebar that only displayed the icons. Hovering over each icon would temporarily reveal the respective card, and users would be able to hover into each card and take actions as they normally would in the expanded sidebar. This concept was received very well in user testing. It cleaned up the view quite a bit and worked even better to reveal all the available features of the sidebar better than before. In the old version, things hidden below the fold were quite undiscoverable, but in the collapsed state, an icon at least provided an affordance for what else existed down there.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fplayer.vimeo.com%2Fvideo%2F366079984%3Fapp_id%3D122963&amp;dntp=1&amp;url=https%3A%2F%2Fvimeo.com%2F366079984&amp;image=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F822010054_1280.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=vimeo" width="1920" height="1188" frameborder="0" scrolling="no"><a href="https://medium.com/media/60526012cdacb703bd58452f69a602db/href">https://medium.com/media/60526012cdacb703bd58452f69a602db/href</a></iframe><p>This minimized state made a huge impact on the legibility of the view. Instead of an entire sidebar, users now only saw a small strip of icons that they could access as needed. We had small badges with counts on some of the icons (like tags and participants) to call attention to them when needed. We also made the choice to keep the sidebar in its minimized state at all times because it’s the better “default” way of using the view. Users could still manually expand it and scroll through the entire list of cards like they could before, if they wished to do so. This collapsed state helped immensely with saving real estate and bringing focus to the actual conversation while still allowing for accessing all the functionality that it had before.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GzLXAroX1WpWeGtLkbAaVA.png" /><figcaption>Our old message composer (top) compared to the one where we made some basic visual updates for consistency (middle). In the beta, we simplified it to the extreme to focus on sending and receiving messages (bottom) and moved the other actions like changing status and tagging to the new Contact Sidebar.</figcaption></figure><p>The final piece of the puzzle to simplify the view was the message composer. Our old message composer was strange, clunky, and felt incredibly outdated. We decided to take a stab at first cleaning up the UI to see if we could modernize it a bit, which we built and shipped. But still, it wasn’t simple enough. There were tons of buttons scattered all over it, irrelevant icons that got in the way, and weird CTAs that didn’t quite belong in a message composer. All of this got in the way of the primary purpose of the feature — to clearly be able to type out and send messages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zaGHwiTt0fiohXUhrtGQrQ.gif" /><figcaption>All the icons that were splattered across the top of the message composer were now moved into a dropdown inside the “+” icon (which allowed room to give them a label and make them clearer). Users could still perform these actions when necessary, but the focus was moved to typing and sending messages as the primary action.</figcaption></figure><p>So we heavily simplified the message composer down to focus on its core essence, which is to type out and send messages. All of the extraneous actions like attaching files, inserting links, and adding internal notes were moved into an overflow menu (modeled after Slack). The other entirely irrelevant features like managing tags and conversation status were taken out of here entirely and moved to the Contact Sidebar. Overall, this felt like a much cleaner and more intuitive method of typing and sending messages. User feedback echoed the same sentiments.</p><h4>Change management</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Up7aXyZRxjNj3QlbbMXf3w.gif" /><figcaption>We added a CTA at the top of the view where all users could opt-in to try out the new experience which included the darkened split sidebar, our collapsing Contact Sidebar, and the simplified message composer.</figcaption></figure><p>As we were launching these big features in the public opt-in beta, we knew we had to deal with educating users about what’s changing and why. We knew there would be a lot of friction to change up an existing workflow to a new one, so we handled this with a lot of caution. In the old Conversations view, had a manual opt-in where people could take these beta features for a spin, with the ability to switch back to the old view at any time. We explained what the new view was before they were switched over and what it did differently from the old one as best as we could.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*Mnico66zsltN1kxRX5geGQ.gif" /><figcaption>Users could give feedback from within the product by either typing it out when switching back to the old view, or click the “Give feedback” link to do the same while continuing to use the new view.</figcaption></figure><p>We knew we needed to learn from users who were taking the new view for a test drive to see what they liked and didn’t like about it. Was it solving problems they previously had? What features did we remove that they find themselves going back to the old view for? What’s their overall reaction to this? So we added two different ways of allowing users to leave feedback. Every time they tried to switch back to the old view, we asked why they were doing so (submitting this feedback was optional). Additionally, we also had a “Give feedback” button right next to the CTA to switch back, allowing users who had decided to stay in the view a way to send us their thoughts on what they thought was better or worse than the old version.</p><p>The feedback that was sent from these modals was piped through a Segment integration into a specific Slack channel where we monitored what users were saying about the new view and its features as we kept shipping changes. The team was quite surprised by the volume of feedback being sent. It was far higher than we expected for a completely optional action. This in-product prompt for feedback ended up being an incredibly valuable tool to inform us about what was and wasn’t working well in the new beta view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hwS7iuDugyLr5BUwoz9VaQ.png" /><figcaption>The ability to bulk close conversations was a feature that existed in the old view which we killed in the new one in favor of simplifying the conversation management experience, but we learned that the feature was a core part of the admin workflow. We got a lot of requests to add it back in, and so we did.</figcaption></figure><p>By far the most popular request to come from the feedback modals was to add the ability to bulk close conversations back in. This was a feature we had in the old view but decided to kill in the new one in favor of experimenting with a simpler approach that didn’t focus too heavily on managing conversations. The usage for it was very low based on our metrics and wanted to see if anyone would care if we simply killed it off. Turns out that they cared a lot, so we added it back in to the beta.</p><p>The few users that used the bulk close conversations feature absolutely needed it for their core daily workflow. These were admins who were monitoring their team’s conversations and would frequently need to close a bunch of conversations at once because the individual salespeople forgot to close them once they were done with qualifying the leads. Upon reaching out to these customers, we also discovered that this was a common workflow on a Monday morning, where admins would bulk close all the conversations that came in over the weekend.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*a1dDYcrxHmRgNC2xdtQs2A.gif" /><figcaption>In addition to bulk close, we also added the next most requested features back in to the public beta over time: the ability to change the sort order of conversations, the ability to change the display density of the view, and allowing users to choose whether or not they wanted a “Send” button to be shown in the message composer.</figcaption></figure><p>Similar to bulk close, we get many requests to add better conversation sorting options, more flexible information information density, and the option to hit a Send button instead of hitting Enter to send their message in the composer. Again, we had originally removed all of these in the new view because we weren’t really sure how valuable they really were for users, despite having some rudimentary click tracking on them. We had fallen into a trap of adding tons of features in the old view but never quite providing users with guidance or best practices for what setting to choose or use for different situations.</p><p>So this time around, we added these most requested features (that we killed in the beta) back to the view in a less obtrusive but still accessible fashion, relying heavily on the <a href="https://signalvnoise.com/posts/3047-the-obvious-the-easy-and-the-possible">Obvious-Easy-Possible framework</a> to decide on how much to expose the features to users. I segmented all our features into these three buckets to ensure that the entire team is aligned on what actions should be obvious, what should be easy, and what should be possible. It cleared up a lot of ambiguity amongst the team when giving design feedback about features that weren’t intuitive at first in the mockups. That was okay, because those features didn’t need to be intuitive, they just needed to be possible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*54FoPWL-zvpniDdFhbKiEw.png" /><figcaption>Responses from the customers who had left in-product feedback after I reached out to them inquiring further about the features they left feedback on. Many of them gave detailed descriptions of how they use Drift and exactly how they wanted certain features to behave for them, which was very eye-opening for the team.</figcaption></figure><p>The best part about getting feedback through these in-product modals was that we had the emails of these customers, which meant I could reach out directly to the customers and follow-up with questions probing further on why they were using a specific feature in a certain way. Over the course of two months, I reached out to over two hundred customers who had provided feedback to get a better sense of their workflows. Many of them happily agreed to jump on calls as well to give detailed feedback about the view. All of this was tremendously valuable in ensuring that we were making the right types of changes in the beta and were addressing feedback as we got it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a3VDmMAewnQ02eFacQtsWg.png" /><figcaption>Some interesting feedback to get on your design work from users. What was most surprising to me is how many users freely admitted to being change-averse and cited that as the cause of them not wanting to try out the new view. It’s a big change and users weren’t opening Drift to learn a new interface, so t made sense.</figcaption></figure><p>An extremely interesting learning from all of this feedback was that users didn’t really hate the new view. They simply didn’t like change. Designers who have gone through rebrands are intimately familiar with this notion, but it was incredible to see so many users flat-out state in their own words that they’re so averse to change. They’d much rather cling to the familiar than experiment with something brand new. They had built workflows and hacks around the clunky, unintuitive ways of working in this view over the past few years and were suddenly being asked to re-learn everything.</p><p>Ultimately, it all makes sense. Users aren’t opening Drift to learn a new interface. They’re not coming here to figure out where the buttons went and how to perform the common actions. They’re just here to qualify leads and hit their quota. This was a humbling learning for the team, because we spend all our days obsessing about how our product should work and behave, but at the end of the day, Drift is simply one of many tools that our users use in their daily workflow. Asking users to re-educate themselves about an interface that they’ve already been trained on and learned beforehand is simply too demanding without much of an incentive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CRqwFAiaZZc05yOKWO4POA.png" /><figcaption>Some users really didn’t like the dark list of conversations. It can be strange to get this type of feedback about something you’re pretty confident about as a designer, but it also puts things in perspective about how your opinions about the view simply don’t map onto users living in it and using it all day.</figcaption></figure><p>And then, we got a lot of users who simply weren’t fans of the dark sidebar. This had me a little rattled at first, because I was pretty sure that this was a good idea right from the start in the Northstar vision designs. Most modern messaging applications do this to differentiate the types of paned content and it seemed like a great fit our view. But it was causing a lot of contrast issues suddenly going from dark to white while going back and forth between scanning the list of conversations and reading the messages in the main window. It’s still not entirely clear whether the users are simply reacting to change here or if this is truly causing big usability issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MBkT76a_N6NN0CWxARDdTg.png" /><figcaption><a href="https://www.intercom.com/inbox">Intercom Inbox</a>’s dark sidebar (left) to the lighter sidebar that they switched to (right) also garnered a similar storm of negativity from users who found the change too jarring when they <a href="https://www.intercom.com/blog/navigating-the-complexity-of-change-aversion/">launched their redesigned Inbox</a>.</figcaption></figure><p>The interesting thing is that even if we went the other way here, we would’ve received similar feedback. Intercom famously went from <a href="https://www.intercom.com/blog/navigating-the-complexity-of-change-aversion/">a dark panel to a lighter one in their Inbox product</a> and their users reacted viciously to the update. Again, they were simply reacting to a big difference in the contrast from what they were used to. Even here, it’s difficult to tell whether this was for the better or not, because reactions to purely visual changes like this are entirely emotional and can be very tough to gauge. We know users will eventually get used to it over time, but there’s no proper to way to ease them into a big visual change like this, so you just have to stick to your guns about the fact that it’s fine and things will calm down soon.</p><p>A final note about this is that when dealing with user feedback through in-app feedback prompts, keep in mind that you’re attracting a lot of negative feedback to start with. Users who are relatively happy with the product typically won’t be looking to voice their happiness through the feedback modals. It’s only the ones who are unhappy with the experience and have something pressing to say that will take a few minutes out of their hectic day to passionately write out a few words about how much they hate the new version. As long as you’re aware of this and are ensuring that you’re not taking too drastic of swings based on what a vocal minority of users say, you should be able to balance and prioritize the right features correctly.</p><h4>Learnings and next steps</h4><p>Once we were confident that all the crucial user feedback had been addressed through the beta period of opt-in testing, we finally decided to kill the old view and permanently switch everyone over to the new view. We now had high confidence in the fact that it was a better experience, and just needed to bring all our customers with us for the ride. We killed the ability to switch back to the previous view and switched all customers to have the new view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x5LvjIbPuGBhagHW8fq14A.gif" /><figcaption>Once we switched all users over to the new view, a “What’s New” CTA at the top of the view triggered a modal that walked the users through all the changes and updates in the new views to make the transition smoother.</figcaption></figure><p>To now deal with the discoverability and re-learning issue, we introduced an in-app education wizard modal that would walk users through all the changes and updates in the view. The CTA for this was intentionally placed right next to the “Give feedback” button so that users had a chance to teach themselves about where something that they were looking for now lived before deciding to drop in a question about missing features. This would also automatically pop up when users would try the view for the first time, just once.</p><p>Here’s some good change management advice for product design in general: try to separate the issue of designing the right experience from the issue of user education. Often in product organizations, we tend to conflate the two and inextricably link them together. Just because something can’t be discovered by users doesn’t mean it’s bad design. It simply means we need to deal with discoverability as a separate issue. Nail the experience first and then worry about ensuring that users are able to find it when they need it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mysl9v87XJXhfCavIBszQQ.gif" /><figcaption>A series of educational GIFs that I put together for sending over to users via a series of targeted email campaigns informing them about all the changes in the view.</figcaption></figure><p>We had even split our users into various segments: ones that had tried the beta at one point but then decided to switch back to the old view, ones that had never switched to the new view, and ones that switched and stayed in the new view. We had different email campaign strategies on how to educate these users about the upcoming changes to Drift, so I created a series of short, digestible, educational GIFs that we could embed in emails and send over to these customer segments. This would ensure that everyone is familiar with all the changes coming to the view.</p><p>Our user retention goal for the public beta was that more than 70% of the users who decide to try the new view decide to stay opted in to the new view. By the time we had decided to switch everyone over to the new view, we had a retention rate of a whopping 96.5%. Despite all the negative feedback through the in-app modals, we were retaining a very high degree of users who seemed to be using the view just fine, so this also gave us a lot of confidence to kill the old view and simply switch everyone to the new view.</p><h3>Bringing it all together</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3w7Oezmlp2mRuS69wz4fVw.gif" /><figcaption>The final redesigned and updated Conversations view (shown with the Contact Sidebar expanded and collapsed). If you’re a Drift user on a Premium or Enterprise plan, this should look familiar to you. This is what the new Conversations view looks like at the time of writing this post (October 2019).</figcaption></figure><p>So there we have it. Two massive failed attempts at bringing about big change later, we took our time and iterated heavily in the existing view that users were using all the time. We took big leaps and made big workflow changes in a public opt-in beta where we addressed as much user feedback as we possibly could before shipping the changes to all users. We forced a big change to happen in a view that’s notoriously difficult to change or update by being very deliberate and intentional with our choices.</p><p>Everything I mentioned in this post happened in the span of eight months. It’s a little hard to believe sometimes, but that’s how fast we were able to push our ideas forward and get user feedback on our work. The key learnings here are:</p><ul><li><strong>Stick with it and be patient.</strong> Making changes in a product that users rely on to make a living as part of their daily work is very different than a consumer app. You’ll fail a lot, and you’ll learn a lot. You’ll get a lot of reactions and opinions, so you need to be prepared to ride out the negative storms until you eventually get comfortable enough to hit the smooth seas.</li><li><strong>Keep users in your process. </strong>One of the biggest failings of the earlier designs and concepts was that we didn’t get as much user feedback as we could have gotten. Who knows what would’ve happened if we added in-product feedback modals and shipped an opt-in beta to a wider audience with the Slack-like inbox version? Hard to say.</li><li><strong>Split apart the experience from education</strong>. It’s too easy to design a great thing and then feel dejected when users can’t seem to find or use your feature, especially in a view which has sixty different things scattered all across it. Don’t worry. Just show them where it is, see if they like it once they can use it, and only then worry about in-app education. Separating these components are essential to drive any product design forward.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*He1MCqhnqK1Sed_5mL8o_Q.gif" /><figcaption>Before and after: The change we pushed in the view over the course of eight months. It’s a night and day difference.</figcaption></figure><p>Finally, I couldn’t have done any of this without the talented group of individuals I’ve had the good fortune of working with at Drift. A huge thanks to my product managers Alexa Nguyen and Daphne Funston, who were crucial in gathering user feedback, defining the jobs to be done, and driving the team forward towards my designs throughout the whole process. And a big hats off to the Drift engineers Mate Rakic, Brandon Read, Dan Whitcomb, Raymond Cox, Trent Duffy, Christian Connelly, Peter Templin, Miro Jelicic, Nadine Shalaan, Bahar Sheikhi, and Luciana Corteggiano for their unrelenting efforts in ensuring that all my designs were built to pixel-perfection and ensuring that the design quality of this view keeps its incredibly high bar through all the crazy iterations and changes it has gone through over the course of all these versions.</p><h4>A sneak peek…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y7eGqW7LEzXtbvuuruxrnQ.png" /><figcaption>Coming soon!</figcaption></figure><p>So what’s next? Well, the team has been hard at work for the past few months on something incredibly exciting. We’ve learned a lot through this process and feel like we have a very good sense of where to head next given what we know about our users’ goals and our own capabilities as a product team. So we’re currently in the early stages of trying something ambitious and exciting where we’re building an entirely new product that has some truly next level stuff in it. Hint: It looks very similar to what some of my Northstar vision designs had, and I’m excited to lead the design and UX of this new product as we test early beta versions of it with customers. More on this soon, so keep an eye out! :)</p><p>Feb 2020 UPDATE: If you’re a Drift customer, you can download the Mac or Windows build of the desktop app <a href="https://gethelp.drift.com/hc/en-us/articles/360041870273">from here</a>. Currently, it only supports the features available on the Free plan, but all paid plan features are being actively worked on and will be coming soon!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a29120554dbc" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/drift-conversations-redesigning-a-shared-inbox-for-sales-teams-a29120554dbc">Redesigning a shared inbox for sales teams — a UX case study</a> was originally published in <a href="https://uxdesign.cc">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[16 lessons from the design world]]></title>
            <link>https://blog.prototypr.io/16-lessons-from-the-design-world-a2cb1eee826d?source=rss-5af7cde87b09------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2cb1eee826d</guid>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Akhil Dakinedi]]></dc:creator>
            <pubDate>Sat, 13 Apr 2019 21:42:02 GMT</pubDate>
            <atom:updated>2019-04-15T15:28:03.277Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*P0igmhUdFxrr8OKGcE4Xlg.png" /></figure><p>Over the past decade, I’ve had a chance to experience life as a professional designer in a wide range of projects and environments, from agency to in-house, freelance to full-time, web to mobile, illustration to UI/UX, graphic design to game design, and user research to product design. No matter what I was doing, there were some common themes and strategies that helped me succeed and grow throughout my various stints, so here’s me sharing some key learnings that hopefully everyone can get something out of.</p><p>These pointers are written as advice and insights from one designer to another, but they’ll be valuable to anyone looking to understand the design process more closely or learning how to collaborate with designers better. The roles and responsibilities of design currently have a huge degree of variance in the industry, so use what’s applicable and take the rest with a grain of salt.</p><h3>1. Fall in love with the problem, not your solutions</h3><p>Like most designers, I got into the industry with a love for good design. I loved obsessing over how elegant the curves on the iPhone are or how intuitive the UI on the Nest thermostat is. But rarely did I ever step back to think about how the creators of these products found themselves even attempting to go about willing those solutions into existence in the first place. They were obsessed with the problem, and stuck with it for an incredibly long period of time while constantly re-framing it and iterating on a variety of solutions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*09tOCi4gJ79hKip_0ZWtIA.png" /><figcaption>The problem space requires the same kind of divergence and convergence of ideas as the solution space does. <a href="https://twitter.com/sovanta_ag/status/935089281932152832">Image credit to Sovanta AG</a>.</figcaption></figure><p>Within the broader problem space, there’s a slew of hyper-specific problem statements that could all have vastly different solutions. Just like you do your due diligence with exploring multiple options and approaches in the solution space during the design process, you also need to be doing the same in the problem space to make sure that your thinking is properly constrained when ideating on the design. If you gain a key insight or learning, the problem should be re-framed to reflect it. Ideas and concepts will be whizzing by in your head in a state of constant flux, but the problem needs to stick in some corner of your brain forever.</p><p>If you don’t spend the appropriate amount of time thinking about the problem, it’s very easy to fall in love with a solution you’re designing and stray too far with it. I’ve made the mistake of getting too emotionally attached to a specific feature or concept only for it to live out the rest of its life as a Sketch file, never making it to users’ hands. In the back of my head, I always tell myself that there’s a 50–50 chance that my designs ever see the light of day, which has served me as a good mental hack to never fall in love with my work.</p><p>I still find myself struggling to ride the fine line between when to flip my thinking switch from problem to solution. It can be very tempting to give one quick look at a problem statement and immediately open up your dot grid notebook to start ideating on potential solutions. Fight this urge. I’ve started to carve time out to explore all the options in the problem space and get to a very specific problem to try and tackle, which has resulted in a lot more relevant ideation in the solution space.</p><h3>2. Focus on learnings, not your final deliverable</h3><p>Iteration is something that we’ve all accepted to be an integral part of the design process. We’ve learned the value of quickly exploring different ideas and eliminating the bad ones before polishing them up too much. But we’re not great at identifying why something doesn’t work. I’m guilty of this myself. I’ll constantly make the same mistakes of iterating in the same way for different designs, without realizing that I had been down that road before.</p><p>The best lesson I’ve learned here is to just stop and think. Every time you’re iterating on a design and it’s not quite working, you’ll find a moment where you’ll catch yourself saying “this doesn’t quite feel right.” Pause here for a second. Start taking notes right next to the design. What about it doesn’t feel right? Is it the tone? The colors? The copy? The visual style? Write it all down. This will help you identify what you actually <em>want</em> it to be, spelled out in clear and confident statements. Then, you use those as the benchmark for the next iteration, continuing the cycle until you come to a version that checks off all the boxes and actually “feels right.” It’s a process of converting the ambiguous subjectivity of the design process to concrete, digestible information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GlY58WC9SedloNOxLZcndQ.png" /><figcaption>An example Slack update at work where I was posting progress of each iteration’s design goals. The format allows everyone to understand the process, encouraging non-designers to contribute to the discussion.</figcaption></figure><p>We mostly make judgement calls when it comes to the look &amp; feel of a product, but when you’re able to describe what you’re going for in words, it suddenly makes the design process accessible to everyone. No longer is it some magical process that happens in the designer’s mind for endless cycles, but it’s a documented set of guidelines you’re working with that helps constrain your thinking and allows others to chime in with feedback, which you can then translate into designs. The ability to do this right is what separates good designers from the best ones.</p><p>Not only does this help your team understand what you’re doing, but it helps you improve as a designer yourself. Knowing that you’ve solved two design problems and are working your way through the next three gives some sense of quantifiable progress, as opposed to discarding entire versions of designs simply because “something didn’t feel right about it.” Try to learn why each iteration failed for each objective, and see where you can mix-and-match the versions to one that satisfies all constraints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7061pjNg7dbD5XhSf4A6DQ.png" /><figcaption>Pentagram’s famed Michael Beirut recently worked on a <a href="https://www.pentagram.com/work/slack?rel=discipline&amp;rel-id=1">rebrand for Slack</a>. Shown here is the design process exploring a few divergent ideas and then converging towards one, iterating on the form independently of color and type treatments before finalizing it and tackling the other issues.</figcaption></figure><p>When Pentagram was working on Slack’s logo redesign, I imagine they went through a similar process. Here’s a sample checklist of how I imagine a designer might have broken this work down:</p><ul><li>[ ] Has to resemble and morph out of the existing octothorpe logo</li><li>[ ] Must work with the existing color palette to retain a sense of familiarity</li><li>[ ] Should represent Slack’s evolution from a startup to enterprise brand</li><li>[ ] Needs to work at all scales and should be usable across the brand’s physical and digital identities</li></ul><p>The right side of the above image only shows the iteration work on the very first bullet point here. You could spend days on just the form before moving on to thinking about color and type interactions. Even across these iterations, you can tell that the designer is struggling to figure out some things, like whether the visual elements should make their way into the wordmark or if they should stay in the brandmark. Things like this only become clearer as you go through the process and talk through them with the client. You learn and define what the brand actually is by answering these questions and making decisions on them as you do the work.</p><p>So don’t get bogged down by the quality of the final deliverable, just make sure you’re transparent about everything it’s achieving (and not achieving). Treat the final design as a by-product of this process, and you’ll feel even better about it because you can point to the drawbacks of the past iterations and speak with confidence about why this is the best one. As a final cherry on top, being transparent with this process provides an excellent framework for the rest of your team to give feedback on your work, as they can lean on specific talking points and know exactly what you are and aren’t trying to do in a given iteration cycle. This works wonders for building the trust of your teammates, because they can now defend your work and explain with confidence what the thought process was for every component of the design.</p><h3>3. Be thick skinned and prepared to deal with all kinds of reactions</h3><p>People generally don’t have strong feelings about how a project manager writes a product roadmap. A marketer won’t ever go to a developer and comment on the quality of their code. But everyone will jump at the chance to react to your designs any day. Positive or negative, they’ll have an opinion. It’s very easy to get discouraged or gain false confidence in your work based on what people say, so dealing with fallout of these reactions requires a thick skin and a conscious effort to realize that it’s not a personal attack on you.</p><p>By nature, design is extremely subjective. Humans react to things based on instinct and gut feel, not with carefully considered thoughts or a detailed list of pros and cons. Design is something that’s very easy to react to, because all you have to do is think about how it makes you feel and then say exactly how you feel. It’s far easier to pinpoint the flaws in someone’s design than create something yourself from a blank canvas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GktEFVhumG3dIloAaylYnw.png" /><figcaption>The internet always goes nuts when popular logos get a brand makeover, incessantly complaining about how much they hate it on social media and endlessly critiquing the flaws with it. Users don’t actually hate the new logo, they just hate that it’s changing. All the companies that have launched rebrands are acutely aware of this phenomenon and know that users will get used to it over time.</figcaption></figure><p>The biggest lesson to learn here is to just remember that when people are reacting to your work, they’re not criticizing your ability as a designer and aren’t questioning the quality of the design itself. They’re just reacting to it, so don’t let all of this take an emotional toll on yourself. They may not be able to create these designs themselves, but they’re absolutely allowed to have an opinion on it. Making this mindset switch me far more comfortable sharing my work and dealing with wildly varying opinions from the rest of the team.</p><p>The best approach I’ve found when drowning in this quagmire of gut reactions is to pick your battles. Playing the game of emotions and feelings that a design evokes is almost always a losing fight that typically ends with a final call made by the most senior person on the team. Instead, focus on what problems a design is trying to solve and back it up with as much evidence as you can collect. Direct user feedback, quotes from qualitative research, and any data or metrics around usability goes a long way to instill confidence about the design amongst your team.</p><h3>4. Seek feedback from everyone</h3><p>This is a skill I frequently get lauded for, and it forced me to break down what actually makes me effective at it. A part of my drive to keep seeking feedback is to constantly be getting fresh eyes on the work I’m doing, as I often find myself overlooking simple things due to being too close to the work and getting tunnel-visioned (which is totally natural and happens to the best of us). Another part of it is to make sure I’m always incorporating a diverse range of thoughts and opinions into my work, which only works if you actively seek feedback from a wide range of people.</p><h4>Asking users</h4><p>Getting feedback from actual users is an absolute must. Some best practices here are to set the expectations correctly — let them know that you’re testing the design (not their abilities), and provide some context about what you’re showing them. If you’re making a change to an existing interface, always show a before-and-after to easily tell the difference. Provide a few questions for them to frame their thoughts around, while being careful not to bias or prime them in any way. For example, asking “How often do you find yourself using this?” will result in vastly different answers than asking “What would be the impact on your workflow if you could no longer see this information?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W5x8dlTM9qSmsAhqsfs_SQ.png" /><figcaption>I was part of the team that ran multiple research &amp; testing sessions in India and South Africa (the targeted launch markets for the product) to get user feedback through interactive prototypes and co-design sessions.</figcaption></figure><p>Even if you do this right, just be aware that users aren’t great at explaining their thought process. You’ll get the common “I like this better” or “I’m confused by this,” but you might find it particularly difficult to get them to explain exactly why as you try to dig deeper to what they’re really trying to say. Asking these questions correctly and following-up on users’ core motivations and goals is an entirely different skillset, so I’d highly recommend pairing up with a dedicated UX Researcher or Usability Tester who can help you navigate the muddy waters of endlessly interrogating users until you get the answers you need to validate or invalidate your designs.</p><h4>Asking your teammates</h4><p>Asking internal team members for feedback is trickier. Users at your company are almost never in the target audience you’re designing for and typically have a much higher degree of tolerance and familiarity with technology. A good example is in one of my previous jobs, where I needed to test some quick copy for an error state in a mobile app when it was offline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VmXUHzQZ3yBm4uwal7BiYw.png" /><figcaption>Something as seemingly simple as copy for an error state can lead to extreme UX problems and mistrust in your product if you don’t seek feedback from the right sources.</figcaption></figure><p>Internally at the company, everyone read the copy which said “Network connection not found”, understood that their network connection was off, and turned it on from the device’s system menu. But things took a turn when testing with real users in-market. Users blamed the product because they didn’t know that their network connections were controlled by their device’s SIM card, not the app they were using. The copy made absolutely no sense to them because it didn’t conform to their mental model of what being online meant. This directly led to a UX improvement where we spelled out what was happening in simple English and explicitly laid out the steps users needed to take in order to get back online and actually use our product.</p><p>If you can’t get feedback from actual users and must rely on your internal team for it, there are still some ways to go about it. Non-designers typically aren’t ever coached on how to give proper design feedback, so you’ll need to do a bit of training. Print out <a href="https://medium.com/@Prozpero/design-critique-cards-6cdad3f1406f">design critique cards</a> and hand them out at random to everyone on your team. This makes it really easy for them to ask directed questions about specific aspects of your work while giving you a chance to defend it, which leads to either validating the idea or rethinking the approach entirely. And it’s a subtle way of infusing a design-oriented mindset within your team.</p><h4>Asking designers</h4><p>Finally, your fellow designers are simultaneously the best and worst sources of feedback you can lean on. Your eagle-eyed peers are excellent at pointing out UI inconsistencies or improper color usage in your design, which can be very helpful. But they also tend to get so bogged down by these design execution details that they often fail to question the bigger goals of the design. I learned how to give and receive design feedback from <a href="https://medium.com/the-year-of-the-looking-glass/how-to-present-designs-4a78c3ebca7b">Julie Zhou’s excellent blog post</a>, which has some great guidelines on how to present your designs to other designers in order to set yourself up to receive the most valuable feedback.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_l1ARw60KmnZ8TLm2loChg.png" /><figcaption>When giving feedback to other designers, just be aware that they’re asking you to genuinely help them improve the design. Let’s be honest that there’s always something to improve on. You should absolutely encourage your peers to become better designers by providing candid feedback about what is and isn’t working.</figcaption></figure><p>This can all seem like a lot. You’re getting tons of feedback from all over the place (even unsolicited) but ultimately, it’s up to you to incorporate them into the design. You’re the final line of defense between what everyone is saying the design should be and what users actually end up seeing and using. Simply adding in the thoughts and ideas of twenty different minds will result in an unfocused and confusing design that tries to do twenty different things and doesn’t manage to do any single thing well. When going through the feedback, ignore the ones that aren’t appropriate and eliminate the ones that don’t work as long as you can justify them. No-one will be offended when you have good reasons to back up your decisions. Only apply what you genuinely think makes the work better, and leave the rest to dust. After all, everything is in service of the users who are the ones going to be using it every day, not the people building it.</p><h3>5. Be highly flexible collaborator</h3><p>One of the engineers I worked most closely with <a href="https://medium.com/@brandonscottread/looking-back-to-look-forward-51f3bb3e6ff1">wrote a detailed post about his career learnings</a>, and I had the good fortune to make a little cameo in it:</p><blockquote>Akhil can throw out a hundred solutions effortlessly, even if ninety-nine of them are thrown away. Fortunately, I balance out the equation by discarding the ninety-nine and quickly find the one that works best. Akhil is a Generator, while I am a Synthesizer.</blockquote><blockquote>What makes this work is that Akhil never assumes bad intent. He knows that all feedback comes from wanting to give users the very best product experience. With that understanding, my continuous commentary is food for Akhil to generate new ideas. We repeat this process over and over, our ideas sometimes meandering, sometimes wandering, and sometimes repeated. We’re quick to recognize when we’re moving in circles and know when to step back and put a stake in the ground or rule out a distracting edge-case so we can make progress. This organic ebb and flow leads to solutions far beyond what either of us could have come up with on our own, even if time was not a factor. I’ve learned that when paired with a Generator, my effectiveness skyrockets.</blockquote><p>Much praise. Reading this made me realize that I tend to constantly switch my collaboration process depending on who I’m collaborating with. I don’t consider myself a “Generator”, but can effectively play that role. I’ve ran design sprints in the past where I’ve played the role of the “Synthesizer” simply because the people in the room were highly vocal and extremely opinionated people. You have to be the one collecting all the divergent ideas and drive them towards convergence in this situation, because if you don’t do it, no one else will . I tend to throw out my own ideas here too, but 80% of my time in these design sprints was spent collecting ideas, combining similar ones, and eliminating bad ones.</p><p>Contrarily, if you’re paired with people who are better at processing ideas rather than throwing them out, you have to be able to turn your “Generator” switch on and go wild throwing ideas out. You’re doing the divergent thinking, and the others will jump in to synthesize all your crazy ideas into a solid few that they feel strongly about. I genuinely believe that this ability to read the room I’m in and adjust my collaboration process accordingly is one of the skills that has gotten me to where I am in my career.</p><p>Practice this yourself. You can probably think of a few people at work who would be good Generators and who would be good Synthesizers. The next time you’re brainstorming something, pay close attention to what the other person is doing and switch your role accordingly. You may have to switch roles twice in the same session depending on how the ideas are flowing and where they’re coming from. If you find yourself struggling to play one role more than the other, keep working on that until it feels effortless. It’ll pay off in the long run because you’ll be able to collaborate effectively with almost anyone, and they’ll be very impressed with your flexibility in the process.</p><h3>6. Explain your thought process</h3><p>This one might sound obvious, but there’s a lot more to it under the surface. When you have the title of “designer”, everyone expects you to “design.” They’re expecting your output to be an interface or an illustration or some interactive animation. While these snazzy mockups will get you lots of Dribbble likes, there’s no substitute for walking people through your process.</p><p>In order for anyone (prospective employers, engineers you work with, your design peers) to trust you in that you know what you’re doing, you need to explain your process. Tell them a story. Start with the user problem, show pictures of your ideation process, show all the alternative scrappy concepts you started making but threw away, explain why you threw them away and what wasn’t working about them, say what you learned, and call out every single design decision you made as you were creating the final version.</p><p>I’m big on this because it shows that you’re able to work within a set of constraints and iterate while eliminating bad ideas and learning about what makes a good product along the way. I’ve gotten hired to most companies I’ve worked at by writing lengthy blog posts about my design process. Here’s an example one for a <a href="https://medium.com/@a_kill_/video-game-ui-the-design-process-explained-14c23fa70d37">video game I worked on</a> and <a href="https://blog.prototypr.io/product-redesign-case-study-evolving-a-mobile-web-browser-73fdd4e04dae">another for a big product redesign</a>. The final outcome of your work doesn’t have to be worthy of putting up on Behance, it just needs to tell a good story and give you lots of talking points about your design process.</p><p>Even when reviewing portfolios of fellow designers and hiring new ones, I’m always looking for the ones who can explain their process well. Sure, there’s a certain bar of quality that their core design work has to meet, but beyond that, the ones that are able to explain the nuances behind every detail are the ones who stand out. Why does this animation need to use this specific spring curve? Why do we need a swipe gesture to transition to this next screen? What’s the value of having such thick strokes on these icons? Be prepared with answers to everything. The worst thing you can say when asked “Why did you choose this primary color for these cards?” is “I don’t know, it felt right to me.” Do your research and back up your claims with evidence. This intentional decision making will naturally lead to better design work.</p><h3>7. Embrace what you don’t know</h3><p>When I entered the industry, I naively assumed that someone with the title “Designer” in their job title essentially did the same thing no matter where they worked. I had no idea how this title could mean vastly different things at different organizations, and how much difference there was in the day-to-day activities of a designer even within the same company.</p><p>When doing freelance design, a lot of my time was spent researching problems and creating moodboards to sell clients on the viability of my approach. At an agency, most of my time was spent presenting my work and learning how to run design sprints. At an early stage startup, I spent most days doing competitive research and conducting user testing to find product-market fit. Now at a mid-stage startup, my days are mostly spent working on shipping designs for big projects within the teams I’m embedded on. Across all these positions, my title was “Product Designer.”</p><p>The title means completely different things at different places. Every time I switched jobs, I had to re-train myself out of the habitual behavior loop that I had acquired in my most recent role. There’s a <a href="https://uxplanet.org/expectation-vs-reality-as-a-ux-designer-working-in-the-big-four-394cea84ab43">great blog post by some designers</a> illustrating the differences of this role at large tech companies. The best trick here is to just ignore the title and treat every new role as a learning opportunity for acquiring brand new skills that will be valuable no matter what ends up happening.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yXOMThrlQaPRsyqrrN7c9Q.jpeg" /><figcaption><a href="https://twitter.com/asallen/status/848636849257984000">Image credit to Andrew Allen</a></figcaption></figure><p>Beyond just the design skills, there’s a whole swath of skills that you’ll need to learn in order to be effective at your job. Design school doesn’t teach you how to write SQL queries to pull the data you need for A/B testing or how to setup an experiment to validate the learnings from it with proper statistical significance. Oftentimes, there wasn’t a dedicated role for this type of work at places that I’ve worked in, so I found myself having to learn and do it myself.</p><p>Similarly, you don’t need to be able to write code to be a great designer (yes, I said it), but you need a basic understanding of how codebases are maintained, how values are stored in database tables, and some programming basics like how conditional logic works in order to effectively communicate with your developers. Writing my own code for prototyping purposes in tools like <a href="https://www.framer.com/">Framer</a> has actually given me a solid footing in the technical underpinnings of the complex front-end JavaScript environments that can sometimes make or break the feasibility of a proposed design.</p><p>It can be so intimidating to learn these new things that it’s easy to say “not my job” and push it off on someone else, leaning on just design as your safety harness to justify your role in the team. But having that baseline level of knowledge in other skillsets has enabled me to communicate with those disciplines in their language and push for things that would’ve otherwise never happened. By speaking their language, I’ve been asked to pitch in during product and metrics review meetings where I’ve gained a better understanding of what we were actually tracking and looking for, which led to tighter integrations between design and data science when it came to testing experience improvements and making small tweaks to move some numbers.</p><p>Embrace these things and treat it all as part of the design process. My golden rule has been “if it’s helping you be a more effective designer, then it’s worth doing,” and this hasn’t failed me yet. I’ve gotten a much better understanding of how product companies work and how design fits into it, both operationally on a day-to-day basis and holistically on a cultural level. Organizations want to be design-driven and are great at hiring designers in order to get there, but aren’t quite sure how to incorporate them into their existing process. It’s up to you to figure out all the moving parts and elevate the value of your work as a crucial component in the organization’s workflow. You’ll pick up a lot of highly valuable skills by learning bits and pieces of the other disciplines and will end up delivering design output that fits far better into the company’s operational process, so there’s really nothing to lose here.</p><h3>8. Use your unique superpower</h3><blockquote>“It’s easy to solve a problem that almost everyone sees. But it’s hard to solve a problem that almost no one sees.” — Tony Fadell</blockquote><p>In his excellent <a href="https://www.ted.com/talks/tony_fadell_the_first_secret_of_design_is_noticing">TED Talk</a>, Tony Fadell spoke about how we become so numb to certain things over time, like habitually peeling the stickers off of fruit before eating them, that we don’t even see it as a problem anymore. We just accept it as a fact of life. Before Steve Jobs mandated that iPhones should come fully charged right out of the box, almost all electronic products were shipping with a “Charge before first use” label. Consumers just expected that from gadgets, but were delighted to discover that they could start using their iPhones right away after unboxing it without having to charge them first.</p><p>It’s these problems that we find incredibly difficult to solve because it’s hard to even notice them in the first place. Design-minded individuals have a special superpower in that their observational skills allows them to spot these flaws. And you don’t have to be a designer to do this. You just need to notice and pay attention to the things you do every day and start taking note of it. Why does plastic wrap have to be that way? How can we make paper grocery bags easier to carry? Why is choosing the right lightbulb for your floor lamp such a difficult process? Start observing and noticing these things.</p><p>As designers, critiquing the design details is actually pretty simple. We’re good at pointing out frictions in an experience or when something doesn’t feel right. It’s easy for any product-oriented person to look at a complex on-boarding experience and come up with a way to improve it, like making sure to provide value to the customer before asking them for payment. They can look at a landing page and immediately point out how to simplify the copy to just get to the point and not get too wordy with it. But if the problem doesn’t exist in plain sight and you’ve developed a habit to tune it out over time, then you need to train your observational skills.</p><blockquote>There are invisible problems all around us, ones we can solve. But first we need to see them, to feel them. Our challenge is to wake up each day and say, “How can I experience the world better?” — Tony Fadell</blockquote><p>In his talk, Fadell lays out how difficult it really is to do this and provides a few key takeaways: think broader, closer, and younger. Zoom out to the larger issue, hone in on the little details, and think with an open mind. It will help you pay attention to things you normally take for granted and will let you see them in a new light. You likely didn’t care about how tedious it was to change the temperature on your thermostat until Nest showed you how easy it could be. Likewise, you probably don’t spend too much time thinking about your toilet until you go to Japan, where you’ll be so blown away by how amazing they are that it’s all you’ll be wishing for after you come back (true story).</p><h3>9. Share your work frequently</h3><p>When I started working at <a href="https://www.drift.com/">Drift</a>, the “Show your work” cultural value was the most difficult one for me to adopt into my workflow. The team expected daily posts updating everyone on what you were doing in order to provide visibility into your work and give everyone a chance to chime in with feedback. This was quite different than how I used to work before, with me spending most of my time researching and ideating for hours (sometimes days) before sharing anything with the rest of the team.</p><p>I struggled to adopt this style of work because something felt off to me about posting half-baked UI work that hadn’t been properly researched or vetted through a proper ideation and exploration process. It’s much easier to pinpoint flaws and poke holes in a design that’s still a work-in-progress than one that’s been thoroughly iterated upon. I was used to filling up entire dot grid notebooks by sketching loose UI concepts for hours and hours before opening up Sketch to mock up three out of the seventy ideas I had. I had to train myself out of this habit. Showing this work early had an added benefit: it let me understand what the team actually cared about in the feature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p7U3LueN2tY0E4ODPtjNmA.png" /><figcaption>Embracing the imperfection: Note how much more feedback is now being incorporated in the same amount of time through more iterations. Being comfortable with sharing rough concepts and ideas early on in the process allows for more feedback faster and lets you ensure a higher degree of accuracy with your final version.</figcaption></figure><p>When you post these loose concepts and early ideas, you’ll notice that people will be all over the place in terms of their feedback. Product managers will comment on very specific use-cases where the design falls apart, engineers will remark on the necessity for investing in a third-party animation library to even think about doing this type of stuff, and data scientists will start suggesting how to run variants of the experiment to A/B test some crucial assumptions we were making. If anything, the feedback generates a lot of open questions that you can then use as constraints for the rest of the process.</p><p>When you begin the design, you’re playing in an open field. There’s little to no constraints and you’re sort of wandering all over exploring things. As you keep sharing the work and keep getting feedback on it, you’re given a chance to narrow down the design so that it fits within all these constraints that are now being exposed to you. You’ll find that many times, different teams aren’t even aware of these constraints until they all start chiming in with their feedback to the design. Just make sure to not get so bogged down with business and technical requirements that you ignore the user problem you’re solving for. If you disagree with what someone’s saying or genuinely believe that a specific interaction model or interface solution is necessary to the experience, speak up and vouch for validating your hypothesis with a quick user testing session. It always clears everything up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YERJdl4AVj2VxBay64GLfQ.png" /><figcaption>As you go through the iteration process and incorporate feedback, more and more constraints are applied upon the design, narrowing the solution space down into a version that satisfies and achieves all its goals.</figcaption></figure><p>A big win here is the team’s exposure to how the design actually evolves through this process. They’re able to visibly see how it has been shaped over time by all the feedback that has been thrown at it. They gain an understanding of design being a continuous cycle of iteration rather than something mysterious that a creative person does in a black box for twenty hours. They start trusting the design process and in turn, start trusting you.</p><p>I’ve started doing this in my freelance projects too and it has improved the client-designer relationship tenfold. I’ve started to convince clients that they’re paying for the process, not the outcome. I share lots of early ideas, frequently show work informally to update them on where I’m at, and often post up sketches or thoughts that I would normally have thrown away or never given the honor of making it to Sketch. Another added benefit is that clients give better feedback during the review sessions when they know they’re paying for the process. They’re consciously aware that everything they say will have a huge impact on the quality of the final deliverable and thus treat them more seriously. Give it a shot if you aren’t used to working like this. It often leads to better outcomes than the traditional process.</p><h3>10. Make designs that spark conversations</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Cet5bFivAuLLuBxIzm2hw.png" /></figure><p>For a while, I had my Slack status set to “sparking conversations all day” with a silly Pikachu emoji. A few co-workers have DM’d me saying that they like the pun (I also happened to be the designer on a product that had to do with managing actual conversations in an inbox at the time), but I was being dead serious. I see sparking conversations as a huge part of my job.</p><p>Before you create anything, the thing you’re building exists only as written feature requirements and abstract ideas in everyone’s heads. They have some reference of how a competitor does it but have no clue what their version of it would be. This is where you’re uniquely positioned as a designer to provide the visual image. Even if it’s loose, even if it’s just conceptual, even if it’s very high-level, just share it out to get a conversation started. If you don’t, you’ll have no idea whether the direction you’re pursuing is right or not.</p><blockquote>“Ideas are misunderstood unless they can be visualized. When a visual is put up on a screen or a prototype is passed around, the whole conversation becomes more productive and specific.” — Scott Belsky, The Messy Middle</blockquote><p>A largely underrated benefit of doing this early in the process is that it exposes all the potential issues we could run into when building and deploying it. A mobile app I was working on wanted a “quick-view” feature that showed only a few essential elements picked out from the detail view of the item, which had over a hundred descriptors about the thing you were buying. Everyone assumed it would be a simple and easy feature to build. Once I shared the designs out, people started realizing how big of an impact this would really have on the user experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IMXu8iahkWPsz28xvNCZug.png" /><figcaption>The proposed full-screen overlay design with the swipeable set of cards proved to be an incredibly problematic interaction model, so the compromise was to build the same layout but embedded into the existing content.</figcaption></figure><p>My proposed design was a swipe-through set of cards that would come up and lay on top of the entire UI when users triggered this quick-view. It caused a lot of chatter amongst the design team about how we would be covering up other callouts underneath the cards, concern amidst the product managers about about how users could fall into a state of endlessly swiping through these cards, and uneasiness within the engineering team about how they’d go about implementing an idea as crazy as this that required fluid motion, overlapping UI elements, and highly responsive animations.</p><p>Because this was shared out so early, we managed to talk through our most pressing concerns and resolve them immediately. We added the appropriate CTAs on the cards themselves, restricted the set of swipe-able cards to fifteen (not infinity), and decided to validate some other UX concerns through user testing with high-fidelity interactive prototypes. We ended up implementing an embedded card carousel within the existing content on he screen instead of doing the full-screen overlay takeover.</p><blockquote>“Sharing a design quickly aligns people. Without it, people are trying to interpret something in the dark feeling one edge at a time. A mock-up or visual is worth countless meetings and debates. A mock-up turns the lights on.” — Scott Belsky, The Messy Middle</blockquote><p>This back-and-forth debate is what aligns your team to pursue a particular approach, and I can’t overstate the importance of making it a habit to consistently keep doing this. Don’t ever feel like you’ve “wasted” time making concepts that never ship, because the value those concepts provide to everyone else cannot be understated. I often have a very clear idea of what 3–5 various visual implementations of an idea might be in my head, but the rest of the team doesn’t until I mock it up and show it to them.</p><p>My only gripe here is that there’s no good way to measure the impact you’re having within the organization by doing this. You could spend 2–4 weeks just ideating and sharing concepts, and your output is clarity within the team about what you’re all collectively working towards. Oftentimes, teams don’t even know there is a lack of clarity until you expose the problem by showcasing the wide variety of reactions to your design. The team will need to naturally trust you and in the design process for this activity to hold any merit, which only comes with experience and repetition.</p><h3>11. Be data-aware, not data-driven</h3><p>When one of the companies I joined said they made all their decisions based on data and metrics, it definitely scared me a little. Would I be able to come in and pitch designs without any numbers to back me up? How would I ship customer value if most of my work is based on subjective appeal and can’t be properly measured? The anxieties slowly subsided when I started incorporating a less aggressive integration of data into my design process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2RnWGAQSDPH6enPslWAJDg.png" /><figcaption>Image taken from “Designing with Data” by King, Churchill, &amp; Tan</figcaption></figure><p>I‘ve written a more <a href="http://akhildakinedi.com/blog/2017/05/11/data-driven-design/">detailed blog post about this</a>, but the essence of it is as so: being data-driven is the most hardcore approach you can take, optimizing and fine-tuning the smallest deviations in your metrics down to an art form. It’s relentless obsession with hard numbers and validating results with statistical significance. Then there’s being data-informed, which is essentially weighing your quantitative testing against the qualitative insights gained from user research or usability testing. It’s a delicate balancing act of taking objective data and backing it up with subjective feedback. And finally, being data-aware means that you’re highly conscious of the limitations that metrics have and only use them as a backup to justify or contradict firmly held opinions about how a product should feel or behave. Being data-aware doesn’t mean you don’t pay attention to the numbers, it just means you don’t fall into the trap of prioritizing metrics over actual customer experiences.</p><p>And it’s probably no surprise to you that design works best in one of these buckets, the data-aware one. The gist of it is that data can only tell you <em>what </em>happened, not <em>why </em>it happened. It’s great at identifying when things aren’t working, but doesn’t provide a clear path on what to do next. All it does is surface the deeper complexities of the problem. It then takes some clever A/B testing, rigorous experimentation, and many design iterations to really validate your learnings through metrics.</p><p>There’s an excellent post about <a href="https://uxdesign.cc/becoming-a-data-aware-designer-1d7614ebc3ed">how to become a more data-aware designer</a>, which I’d highly recommend reading. In one of the High Resolution episodes, <a href="https://www.youtube.com/watch?v=DCWd9rXtfOE">Spotify’s VP of Design Rochelle King</a> explains the huge benefits of becoming data-aware in your design process. Depending on where you work, you may be forced into a data-informed approach to your designs. This can still work, as long as you constantly remind the rest of your team to balance the numbers with what you’re actually hearing from customers.</p><h3>12. Observe and listen more than you talk</h3><blockquote>“We’ve got two eyes, two ears, and one mouth. Use them in that proportion.”</blockquote><p>When you’re asking veteran users of your product research questions about usability or their workflows, you’ll get a lot of mixed feedback. Pay close attention and you’ll realize that these users are consciously forming their opinions about what you asked them on the spot right as they’re answering the question. They get so accustomed to using common products and features that it can be difficult for them to express how they really feel about it.</p><p>I once had to ask a series of questions about what types of files users were uploading as attachments to their messages. They’d respond with the usual “you know, images and stuff, etc.” I’d take notes, ask what image file formats as a follow-up question, and move on. Midway through the tests, I noticed users were just blurting something out just so they had an answer ready for me. What they said may not have been what they actually did.</p><p>So I switched up my strategy. I asked the question and then they responded with their first answer. Instead of following up to the question, I just sat there in silence. Sometimes for ten to thirty seconds. This felt very awkward at first, but it allowed the participants to ease up and think a little deeper about what was asked. One user mentioned he recalled trying to upload a video file that caused the upload bar to get stuck. Another user mentioned he frequently uploaded his resumé as a PDF with the same filename, and that the system sometimes had trouble overwriting the previous upload with the new one. And both these people initially answered with “mostly images and pictures.”</p><p>Had I just followed-up and moved on, we would’ve never arrived at these great insights. The time and silence that you give the users allows them to ease up and think a little deeper about what’s being asked. It reinforces to them that you’re genuinely there to listen to them, not just incessantly pester them with a series of questions about what they do in the product. Again, this is extremely uncomfortable to do as the moderator, because we’ve been trained from childhood to hold a conversation and keep it going, so allowing for long pauses like can feel quite unnatural at first but gets easier with time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gk_PRoin_IS9j1lsv7t9Pw.png" /><figcaption>Ergonomics in action: Users unconsciously grip their device in different ways depending on where the UI elements are. Here, the user instinctively starts to hold their device with both hands in order to access the menu items in the iOS Action Sheet, despite being able to reach them with one hand.</figcaption></figure><p>The same goes for simple observation. Just watching users use your product without asking any questions can provide so many valuable insights. You’ll pick up on things users are subconsciously doing that even they’re not aware of. I was sitting in a usability testing session for a mobile app where a user was going through a prototype I had designed. They were holding the device comfortably with one hand the entire time. One of the tasks required them to share a link, so they clicked on the relevant item and the default iOS Action Sheet popped up from the bottom of the screen. Then, they instinctively clutched the device with both hands and chose an option in the menu with the thumb of their other hand. It was an automatic, instinctive motion with no forethought or intent.</p><p>Despite there not being a huge spatial distance between where they triggered the menu from and where the menu options popped up, something in the user’s brain told them that it’s more efficient to move their entire other hand over and use it instead of just re-adjusting their grip with the existing hand. This may not sound like a big deal, but imagine if they were on the subway and needed that other hand to hold on to something. There’s situational friction in the experience. Now that devices are getting larger and larger, ergonomic issues like this are more important than ever to consider for accessibility and inclusive design.</p><blockquote>“Interrogation and empathy can get you incredibly close to your users.”</blockquote><p>Usability tests and research sessions are great to figure out where your designs and prototypes fall apart, but try to listen more than you talk and try to really observe the subtleties and nuances in their actions. Your questions must be combined with a sense of empathy for the users’ goals in order for the true user experience to fully reveal itself to you.</p><h3>13. Keep Calm and Design On</h3><p>No amount of coaching in art school, design school, or a UX bootcamp really prepares you for how chaotic things can really get at tech startups. There’s always disagreement amongst teams about what the right course of action is and second thoughts on tough decisions that need to be made. Once you start mocking up some of the ideas, it gets even crazier with everyone chiming in with their thoughts on what should be changed or improved.</p><p>The best trick in the book here is to simply maintain your composure through the chaos. Always be grounded and never lose your cool. As a designer, you’ve likely already come to terms with the fact that the design process can be messy. Others haven’t, though. They don’t live and breathe design every day. People will disagree with your approach and will sometimes switch up the product strategy entirely based on what the mockups are starting to look like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f24Mv16LWzv4wt_mxmzQ-w.png" /><figcaption>Image credit to <a href="https://medium.com/@pablostanley">Pablo Stanley</a>, who also comes highly recommended for his hilarious posts and illustrated stories about how to stay sane as a designer in the frenzied and chaotic world of tech today.</figcaption></figure><p>Throughout all this, all you have to do is not freak out. Accept it as part of the process and just go with it. Believe it or not, you’ll garner even more respect from your peers by being the epitome of calmness amidst the frenzy. The ability to persist in the madness and just constantly keep doing the work is an extremely underrated skill of being a good designer. Being able to carry yourself with enough patience and confidence with your execution skills ends up paying huge dividends down the line.</p><p>I should also mention here that it’s still up to you to fight for the user experience. The design team tends to be severely outnumbered in most product teams by engineers, data scientists, business analysts, and product managers. They’re all mostly laser-focused on their most crucial job functions, and even though they care deeply about a good user experience, they’re not necessarily prioritizing it over the work they need to get done. You may find yourself in a position where you absolutely need to speak up and say that you’re not okay shipping a feature that doesn’t meet the bar for a good user experience. Ultimately, the shippable version ends up being a compromise due to time and resourcing constraints, but just know that you’re the strongest advocate on the team for shipping a good user experience.</p><h3>14. Visibility &amp; optics matter</h3><p>My “design process” used to be the same for a long time. I would be presented with a problem, and I would go down a research hole for a while. I’d scope out competitors, weigh it against our product strategy, and familiarize myself with the nature of the market. Then I’d start doing design research by looking at UIs and benchmarking best practices while taking a mental note of all the conventions being used that users would be familiar with. Then I’d loosely sketch out a bunch of ideas and approaches in my notebook to quickly invalidate the bad ones and decide on one or two worth pursuing.</p><p>Until this point, everything that’s been done isn’t visible to my peers. It’s all in random screencaps and pages of a sketchbook, along with some screenshots or GIFs of me tinkering with competitor products. This process can take up to an entire week for really complex problems, and not having a deliverable yet results in zero visibility to your team into what you’re actually doing. And people start wondering what you’re really doing if you’re not “designing.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BztfBahG5QC3mJaB91dIDw.png" /></figure><p>At Drift, there’s an internal rule that every designer posts what they’re working on twice a week, every week to a public #design channel in the company’s Slack. The post can be anything from an entire flow to a small screenshot of a new toggle somewhere deep in a Settings page. It can be in any format, like a clickthrough InVision or a simple GIF animation. What this does is provide visibility to the rest of the company into what the designers are actually doing. Even if all you have is a basic wireframe, you’re encouraged to share it. The purpose isn’t for anyone to attack your work and tear it apart, it’s just for them to look at it and go “ah, so that’s what this designer is working on.” It also gives them with a good chance to provide some off-the-cuff feedback about copy or UX, which they normally wouldn’t have a chance to do until the very final version that I would’ve normally shared out.</p><p>I initially found this rule difficult to incorporate into my process, but it got much easier as time went on. It served as a nice forcing function to not spend too much time dabbling in the research phase and actually put something together in order to get some people reacting to it. Even if it isn’t final, it gives everyone a basic sense of where my head’s at and what direction I’m thinking of pursuing with a specific problem. If something does require a lot of upfront research, we can always post a teardown of a competitor product critiquing the UI and calling out things that do and don’t work well for our purposes. At the very least, it’s actually letting people know that I’m doing the research, which they wouldn’t have known if I hadn’t posted anything.</p><p>Note that this will vary depending on where you’re working. At creative agencies, it’s understood internally that the design process is chaotic and we sometimes need to fumble with a some creative approaches for a while before arriving at something good. At one point, I expressed concern to my manager that I was spending too much time crafting emails to clients explaining my work and specifying what type of feedback I was looking for. I wanted to spend more time actually doing design work. My manager responded by saying that convincing clients and properly communicating your thoughts is all just a part of the design process, and that it’s okay to spend most of your week writing emails and cleaning up your presentation slide deck.</p><p>Early-stage startups that haven’t quite achieved product-market fit yet expect designers to spend a lot of time doing user research to figure out some key insights about the market. But at established tech organizations that have a solid product pipeline, you’re expected to constantly be shipping UIs and you’ll quickly need to adjust to how often you’re sharing your work, because the optics are a big deal in ensuring that everyone knows you’re working on the right things.</p><h3>15. Never stop learning</h3><p>Putting this in here at the risk of sounding cliché, but it’s an incredibly useful lesson. No matter how experienced or how good you get, there’s always something you can improve on. Design has so many areas you can go broad and deep with overlapping skillsets that it’d be a waste to not at least try everything out. If your day job primarily involves UX, flex that illustration muscle through side projects. If you tend to work solo on projects at work, try to do a group project with other design disciplines whenever possible. The opportunities are all there, and you might discover an area of design or product that you really like but never had the chance to properly explore.</p><p>Even as you advance strictly in your specialization, you can learn a lot or pass on your learnings to the junior designers. It’s quite easy to spot out the strengths and weaknesses of your peers, so try to make a habit out of learning the skills that you know you aren’t great at from the ones who are and pass on some learnings about things you actually are good at to those that could use it. There’s a great blog post out there about the <a href="https://www.vanschneider.com/junior-designers-vs-senior-designers">difference between junior and senior designers</a> that exposes the behaviors and thinking of more experienced designers from the younger ones, so keep an eye out for these and train yourself to see the bigger picture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NfesN7YWS_JAMc66JdZNAQ.png" /><figcaption>A collection of the podcasts, mini-series, and books (links below) that I’ve found to be most influential on my daily life and in reshaping my perspective on how design fits in to the broader context of human perception in relation to products, technology, and business.</figcaption></figure><p>Depending on where you work, the things you do on a day-to-day basis can be so hyper-specialized that you don’t have a good baseline for what other designers at other organizations are doing. Listening to interviews or podcasts is a great way to keep up with that’s happening. The <a href="https://www.youtube.com/channel/UCzBkNPSxw15qrW_Y8p-oCUw/videos">High Resolution interview series</a> is an excellent one to listen to design leaders talk about how they organize and manage their teams, <a href="https://slackhq.com/work-in-progress">Slack’s Work In Progress</a> is an excellent resource for a fresh take on the general nature of work and life, and <a href="https://www.npr.org/podcasts/510313/how-i-built-this">NPR’s How I Built This</a> is a fascinating look at how the most recognizable brands and apps today got their humble start. Beyond that, there’s <a href="https://www.imdb.com/title/tt6333098/">Abstract, the Netflix mini-series</a> about design and the consistently good episodes of the <a href="https://99percentinvisible.org/">99% Invisible</a> podcast.</p><p>And of course, there’s over a hundred design books I could probably list off that are excellent reading material, but if I had to condense it down to five, it would be: <a href="https://www.amazon.com/Elements-Typographic-Style-Version-Anniversary/dp/088179211X">The Elements of Typographic Style</a>, <a href="https://www.amazon.com/Design-Everyday-Things-Revised-Expanded/dp/0465050654">The Design of Everyday Things</a>, <a href="https://shapeofdesignbook.com/">The Shape of Design</a>, <a href="https://abookapart.com/products/design-for-real-life">Designing for Real Life</a>, and <a href="https://www.amazon.com/Understanding-Comics-Invisible-Scott-McCloud/dp/006097625X">Understanding Comics</a>. All of these take a unique look at design from very different lenses and I credit most of my biggest learnings to these books.</p><h3>16. You can’t be good at everything</h3><blockquote>“Getting good at doing what you love means having the confidence to recognize what you know, the humility to recognize what you don’t, and the courage to extend our respect to those who make our faults more visible.”</blockquote><p>When I was first getting into design and learning the ropes, I was filled with a fresh kind of energy to learn everything I possibly could and excel at every aspect of design. I wanted to make amazing visual effects, master typography, become the best motion designer, understand animation really well, know color theory so well that I could make palettes in my sleep, and come up with novel interaction design patterns that felt incredibly intuitive on my first try.</p><p>As I got older, I quickly started realizing that I simply couldn’t be all those things. I definitely tried, but it either became painfully obvious that it just wasn’t for me or that I didn’t certain aspects of design enough to keep pushing myself to get better at them. I had to very consciously think about what parts of design I actually enjoy struggling through and persisting until I arrive at a good solution, and leave the rest for others who were better at it than I was.</p><p><em>“Great designers realize you can’t know everything and are comfortable with high levels of ambiguity. “ — </em><a href="https://twitter.com/andybudd/status/1027592356445474816"><em>Andy Budd</em></a></p><p>Five years ago, I would jump at the chance to do any design work that anyone needed with gleeful optimism. Today, if someone needs a logo made, I politely decline and refer them to three designers who I know can do a much better job than I could. But if someone needs to run their app’s navigation structure by me, I’m all ears. And this is all because I’ve recognized that I enjoy debating the nuances of navigational UX in a product far more than obsessing over the details of emblems and symbols that make a good recognizable logo for a brand. And I can do it for far longer and make meaningful contributions to improving the navigation, whereas I’d likely fumble and mess around with the logo a few times before going “ehh, this seems good enough”, knowing full well that it would’ve turned out a lot better if a designer who cared more about it were to have tackled it instead of me.</p><p>As I keep growing in my design career, I’m constantly re-thinking what my strengths within design really are and am making a conscious effort to hone in on to those. This can be tough because it means giving up things that you know you enjoy doing but aren’t necessarily the best at. But it’s a sacrifice that must be made in order to get even better at what you do enjoy doing and are indeed good at. It’s a stark difference in the way I approach projects and problems, and it can be quite liberating to accept your weaknesses and substitute them for your strengths.</p><h3>Closing thoughts</h3><blockquote>“People may forget what you said, but they’ll never forget how you made them feel.”</blockquote><p>You’ve heard the quote, and it holds true for your interaction with products and people as well. Fifty years from now, we won’t remember the micro-interactions of Slack or what channels we frequented. We’ll remember the overall experience we had in it and how we felt using the product. I’ve watched a ton of movies and played a load of games, but there’s something that made the memorable ones stand out. The takeaway is simple to say but incredibly difficult to accomplish: make your products feel memorable.</p><p>The same goes for your co-workers and people that you built these products with. They likely won’t remember what you worked on or what products you shipped, but they’ll remember what it was like talking to you and interacting with you. The more seamless and pleasant you can make this, the better your interactions will be with everyone (not just at work, but in life too).</p><h4>The path forward</h4><p>It felt a little strange to even write all of this out, because many of these learnings only happened in hindsight. None of them were obvious as they happened to me. It was only after two or more years of intensive retrospection that I was able to frame what really happened in the context of my actions. As I keep growing, I expect I’ll keep learning and reflecting on even more key lessons. Just like a painter constantly has to step away from the easel to examine the overall balance of color, form, proportions, and feel, we constantly need to be re-assessing not only our own design work but also how we fit in to our organizations and where we’re going in our own careers.</p><p>Overall, I hope these insights have been valuable to other designers looking for some advice in navigating the messy waters of design in their early career. There aren’t many lifeboats out there and it’s easy to feel like you’re drowning instead of riding out the waves, but having the right mindset and expectations can keep you afloat for much longer than you might think. Stay ambitious while being humble, and the resulting currents of curiosity will carry you to some really exciting shores.</p><p>Thanks for reading! As always, please feel free to leave responses below or reach out to me directly via <a href="mailto:dakinedi@gmail.com">email</a> or <a href="https://twitter.com/a_kill_">Twitter</a> for any thoughts, musings, contemplations, and comments. For further reading, I have some more longform writing on <a href="http://akhildakinedi.com/blog/">my personal blog</a> about design and other topics.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2cb1eee826d" width="1" height="1" alt=""><hr><p><a href="https://blog.prototypr.io/16-lessons-from-the-design-world-a2cb1eee826d">16 lessons from the design world</a> was originally published in <a href="https://blog.prototypr.io">Prototypr</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>