<?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 Ola Mishina | Lead Product Designer in CCaaS on Medium]]></title>
        <description><![CDATA[Stories by Ola Mishina | Lead Product Designer in CCaaS on Medium]]></description>
        <link>https://medium.com/@olamishina?source=rss-f2d5b8fdb65b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*n-VUFaaPQIUcSlnCkNrpqQ@2x.jpeg</url>
            <title>Stories by Ola Mishina | Lead Product Designer in CCaaS on Medium</title>
            <link>https://medium.com/@olamishina?source=rss-f2d5b8fdb65b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 17:39:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@olamishina/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[What Makes a Good Designer a Great One]]></title>
            <link>https://medium.com/design-bootcamp/what-makes-a-good-designer-a-great-one-cc96b1ea1de0?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc96b1ea1de0</guid>
            <category><![CDATA[soft-skills]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-designer]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Tue, 11 Nov 2025 20:42:34 GMT</pubDate>
            <atom:updated>2025-11-17T22:02:55.500Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Good vs Great comparison" src="https://cdn-images-1.medium.com/max/1024/1*86v0nErJFU4I89r7E1xnsg.png" /></figure><p>There are plenty of good designers out there. People who make things look nice, know their tools, and deliver on time.</p><p>But what separates a <em>good</em> designer from a <em>great</em> one isn’t about Figma frames or fancy micro-interactions. It’s about how you think, communicate, and collaborate.</p><p>Here’s what I’ve learned along the way 👇</p><h3>1. Manage stakeholders’ expectations</h3><p>Design is not just about pixels. It is about people. Great designers know how to set expectations early and manage them often.<br>Your PM does not like surprises. Your developer does not like last-minute changes. And your boss definitely does not like scope creep.<br>Keep everyone aligned and calm. That alone can save a project.</p><h3>2. Bring solutions, not complaints</h3><p>Anyone can spot problems. Great designers bring ways forward.<br>Instead of saying “This pattern doesn’t work,” try “This pattern doesn’t work any longer. What if we explore alternative options and test them?”<br>You do not need a perfect fix every time, but you should always think in solutions.</p><h3>3. Listen, really listen</h3><p>Most design mistakes do not come from lack of skill but from not hearing what was actually said.<br>Listen to users. Listen to your PM’s priorities, your developer’s constraints, and your teammate’s critique.<br>Absorb before you respond.</p><h3>4. Adjust your context for each audience</h3><p>Be loyal to the people you are talking to.<br>Your PM already knows the problem, so get straight to the decision.<br>Your design peers need context. Explain the “why.”<br>Your developers need clarity. Focus on states, edge cases, and logic.<br>Tailoring your message saves everyone time and patience.</p><h3>5. Respect people’s time</h3><p>Be short. Be clear. Be neat.<br>Nothing says “senior” like summarizing a complex flow in two sentences instead of fifteen.<br>And please, do not call your PM every fifteen minutes to clarify a small detail or share a half-baked idea unless they asked you to. Collect your questions, organize them, and schedule one focused chat.<br>Respecting people’s focus time earns you trust and usually better feedback.</p><h3>6. Prepare for design reviews</h3><p>When you gather people for feedback, come prepared.<br>Remind them what was discussed last time and what you have already improved. Nobody remembers what they said two weeks ago. That is your job.<br>Treat feedback as raw material, not as noise.</p><h3>7. Design your design artifacts</h3><p>Your mockups are also a product.<br>A great file does not just look good. It reads well.<br>If your design needs a live walkthrough every time, it is not finished yet.</p><h3>8. Keep learning</h3><p>Great designers never stop learning. They stay curious about new tools, frameworks, and technologies, not because it is trendy but because the industry moves fast.<br>AI is already changing how we research, test, and prototype.<br>The goal is not to chase every shiny tool but to understand what is changing and how it can make your work smarter, faster, or simply more human.<br>Staying curious keeps your skills relevant and your mind sharp.</p><h3>In short</h3><p>A good designer creates solutions.<br>A great designer creates <strong>clarity</strong>, <strong>trust</strong>, and <strong>momentum</strong>, and keeps learning along the way.</p><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please 👏 so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc96b1ea1de0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/what-makes-a-good-designer-a-great-one-cc96b1ea1de0">What Makes a Good Designer a Great One</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[First Steps as a New Product Design Lead]]></title>
            <link>https://medium.com/design-bootcamp/first-steps-as-a-new-product-design-lead-e41b35f0832a?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e41b35f0832a</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[design-leadership]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Fri, 23 May 2025 17:55:55 GMT</pubDate>
            <atom:updated>2025-11-11T20:39:39.612Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*MSyX723u1V1MJd6K5aj1lQ.png" /></figure><p>When you join a company, they expect you to start performing fast. And you probably won’t get the luxury of building everything from scratch. In most cases, you’re stepping into existing workflows, legacy tools, and unspoken rules. Your job? <strong>Deliver, while quietly laying the groundwork for better design.</strong></p><p>And don’t expect a red-carpet onboarding either. Most companies don’t have a perfectly structured onboarding process — especially for design leads. You’ll often have to figure things out yourself. Later, it’ll be your job to build that onboarding structure for your team. But first? <strong>You observe, ask, and navigate on your own.</strong></p><p>Of course, the most obvious thing: you need to get familiar with the product. Know what you’re designing, how it works, who uses it, and where it’s going. <strong>But honestly, that part’s kind of obvious.</strong> Let’s talk about the things that often get overlooked — but make all the difference when you’re leading design.</p><h3><strong>1. Observe First, Judge Later</strong></h3><p>Don’t jump into fixing or critiquing everything you see. First, understand <strong>why things work the way they do</strong> — tech constraints, team history, resource limits. Just because it’s not how <em>you</em> would do it doesn’t mean it’s broken.</p><p>Some new leaders fall into the trap of overjudging: “This isn’t how it should be done!” They try to change everything right away. It’s a disaster — for the team that’s been making it work, and for the newcomer who quickly loses trust. Respect the context before trying to improve it.</p><h3><strong>2. Meet Your Team and Build Relationships</strong></h3><p>Set up 1:1s with Stakeholders, PMs, POs, Devs, QA, and every designer. Ask questions — mainly about what they do, how they do it, and what collaboration with designers usually looks like. Why? Because roles and responsibilities vary a lot between companies. Listen more than you talk.</p><h3><strong>3. Understand Where Work Comes From (and How It’s Tracked)</strong></h3><p>Figure out <strong>who creates design tasks</strong> — PMs, Devs, Stakeholders, even support teams. How are requests coming in? Is there a backlog, a board, or is everything buried in Slack threads?</p><p>Then, understand how progress is tracked. What’s the team’s system — Kanban, sprint boards, Notion, JIRA? If it’s unclear or inconsistent, help build something simple and visible. Without clarity, the team (and you) will always feel behind.</p><h3><strong>4. Define What “Design Done” Means</strong></h3><p>Align early on what counts as “done.” Who approves the work? What needs to be included? Is QA reviewing designs too? Avoid the endless loop of feedback by setting clear expectations.</p><h3><strong>5. Align on Handoff and Reviews</strong></h3><p>Agree with developers and QA on how design is handed off and how implementation is reviewed. What tool do you use? Who checks builds? Is design QA part of the sprint?</p><h3><strong>6. Set Up Team Rituals</strong></h3><p>Before diving into design systems or UX audits, get your basic team routines in place — daily standups to track progress, and weekly planning to stay aligned. Keep it lightweight and useful. These small rituals build team rhythm and clarity.</p><h3><strong>7. Go Strategic</strong></h3><p>Now it’s time to zoom out — tackle design system updates, clean up UX gaps, plan long-term initiatives, and improve or build new processes. By this point, you’ve earned trust and gathered the insights to do it right. Strategy works best when the basics are already in place.</p><h3>One Last Thing</h3><p>And if you’re thinking, <em>“How on earth do I juggle all these steps at once?”</em> — fair question, but that’s a topic worthy of its own article. Every Design Lead leans on different tools and tricks, and learning to keep all the plates spinning is part of the job.</p><p>Start strong, stay smart. Respect what’s there. Fix what matters. Build trust before making noise.</p><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please 👏 so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e41b35f0832a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/first-steps-as-a-new-product-design-lead-e41b35f0832a">First Steps as a New Product Design Lead</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Process Limbo: Discovery & Concept Design]]></title>
            <link>https://medium.com/design-bootcamp/design-process-rethinking-discovery-concept-design-4369ddcc613e?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4369ddcc613e</guid>
            <category><![CDATA[concept]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[discovery]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Sun, 03 Mar 2024 21:22:23 GMT</pubDate>
            <atom:updated>2025-12-29T12:22:35.617Z</atom:updated>
            <content:encoded><![CDATA[<h3>Design Discovery for Complex Systems: A Practical Approach</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P8TjLoeWUbKs0DXMLNw-rQ.png" /></figure><p>In the ever-evolving landscape of software design, launching on the initial stages of the design process is like navigating through a complex labyrinth. These foundational rituals — known in our circles as R&amp;D, research, discovery, and exploration — act as the foundation from which ideas are sculpted into actual concepts/wireframes/sketches/drafts. These key things not only lay the groundwork for development and meeting business objectives but also hold the key to setting design projects off in the right direction, at times, shaping the entire architectural framework.</p><p>I am sure everyone is familiar with the honorable <strong>Double Diamond</strong> and <strong>Design Thinking</strong> — the industry’s equivalent of pop stars. They’re cool, they’re everywhere, and they promise to change your life. However, when faced with the reality of day-to-day work, they often fall short of providing the practical guidance needed by most organizations. They’re like that friend who says, “Just follow your dreams!” but doesn’t give you a map or even a compass.</p><p>This realization sparked a journey for me as a Design Lead:</p><ul><li>How these initial steps should be performed in my team?</li><li>What truly indicates the progress of the discovery, and can I articulate it into a framework that guides our team forward?</li></ul><h3>The Objective of Discovery and Concept Design</h3><p>When it comes to practical appliances in the daily design work, the Discovery and Concept Design phases are inseparable. It is impossible to perform these activities independently.</p><p>Why, you might ask? Because I don’t think that someone could value the Discovery phase merely for the sake of documented research artifacts. Discovery is the stage where designers should gather and analyze information that will enable them to translate it into solutions. Therefore, what we truly aim for is to <strong>deliver solutions that are profoundly informed by the Discovery findings. </strong>So, what does the final delivery of these solutions look like in this context? It naturally evolves into Concept Design.</p><p>In the realm of how design works inside organizations, Discovery and Concept Design don’t just hold hands; they’re doing a tango. It’s a bit like being a detective in a mystery novel: the more clues you uncover, the closer you get to solving the case. Except here, the case is a design challenge, and your clues are insights and data. The deeper you dive into the concept, the more you realize you might need to double back for more intel — a classic “two steps forward, one step back” dance move.</p><h3>My approach</h3><p>I’ve announced <strong>the merger of Discovery and Concept Design into one cohesive phase</strong> and have formulated the definitions and guidelines.</p><blockquote>The key Definition of Done (DOD) for this phase is simply: a design solution, informed by research findings, that effectively addresses the task goal.</blockquote><p>Please note that I do not prescribe here a specific method for conducting and documenting the discovery artifact/research (as there is a plethora of information available on the topic, warranting a separate article).</p><p>So let’s begin.</p><h4>Phase workflow</h4><p>Observe the target space ← → examine findings ← → propose a solution.</p><h4>Definition of the concept</h4><p>A concept might be an individual visual (mockup) or a set of visuals (wireframes) forming user flows/diagrams that <strong>reflect the solution</strong>, informed by discovery insights.</p><h4>Golden rules</h4><p><strong>⭐️ Importance of the correct place</strong>. <br>Whether in Figma or Google Drive, all artifacts and concepts should reside in a singular, accessible location. For instance, we utilize a dedicated ‘Discovery’ project in Figma for this purpose.</p><p><strong>⭐️ No evidence — no work. <br></strong>Googling competitors without documenting is like saying you went to the gym but only took a selfie outside. Every piece of research must be recorded to guide our decision-making.</p><p><strong>⭐️ History of review rounds.</strong> <br>Documenting the evolution of our designs through review rounds is essential, providing a clear track of progress and decision-making rationales.</p><h4>Discovery checklist</h4><blockquote>Please note that this checklist is a recommendation, and completion of each step is not mandatory. The application of specific methods depends on the project’s needs and complexity.</blockquote><p>✔️ <strong>Understanding and processing project requirements.</strong><br>Thoroughly review project documentation, briefs, and discussions to comprehend project objectives, scope, and constraints. Clarify any ambiguities/unknowns and ensure alignment with stakeholders regarding project goals and expectations.</p><p>✔️ <strong>Defining user roles, use cases, and workflows.<br></strong>Identify key users representing their jobs to be done or actions. Define use cases and scenarios to understand how each user role might interact with the product in various contexts. Map out workflows to visualize the user journey, interactions, and touchpoints with the product.</p><p>✔️ <strong>Exploring product architecture and in-product behavior patterns.</strong><br>Study the product architecture, including its components, modules, and data flows, to understand how the system functions. Analyze existing in-product behavior patterns to maintain consistency and coherence across different features and modules.</p><p>✔️ <strong>Analyzing dependencies within the product/service/entity.</strong><br>Assess if the requested domain depends on other parts of the product or external systems. Identify potential integration points and dependencies to ensure seamless functionality and user experience.</p><p>✔️<strong> Observing potential blockers and corner cases.</strong><br>Anticipate and identify potential blockers, challenges, or edge cases that may arise during the design process or product implementation. Proactively address these issues through strategic planning and risk mitigation strategies.</p><p>✔️ <strong>Conducting competitor&#39;s audit.</strong><br>Evaluate competitor products and services to understand market trends and areas for improvement or innovation. Identify strengths and weaknesses of competitor offerings to inform design decisions and differentiate the product.</p><p>✔️<strong> Facilitating additional UX research methods.</strong><br>Determine if additional UX research methods, such as user interviews, surveys, or usability testing, are necessary to gather insights into user behaviors and preferences. Plan and execute research activities to validate assumptions, gather feedback, and refine design solutions.</p><p>✔️ <strong>Involving developers to address potential pitfalls.</strong><br>Collaborate with developers to understand technical constraints, limitations, and opportunities related to the design. Seek their input on potential pitfalls or obstacles and explore feasible solutions that balance user experience and technical feasibility.</p><h3>Conclusion</h3><p>In wrapping up, the outcome of this phase is a well-structured presentation for stakeholders and managers, seamlessly guiding them through the decision-making process with solid evidence pointing towards the proposed solution.</p><p>In my experience within our organization, this approach has proven to be incredibly beneficial. It fosters collaboration with managers and ensures clear expectations for this phase, making sure everyone is on the same page and moving forward together smoothly.</p><h3>Recommended articles</h3><p><a href="https://www.smashingmagazine.com/2023/08/improving-double-diamond-design-process/">Improving The Double Diamond Design Process</a> by Andy Budd</p><p><a href="https://www.nngroup.com/articles/discovery-phase/">The Discovery Phase in UX Projects</a> by Maria Rosala</p><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please 👏 so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4369ddcc613e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/design-process-rethinking-discovery-concept-design-4369ddcc613e">Design Process Limbo: Discovery &amp; Concept Design</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building UX for Error Validation Strategy]]></title>
            <link>https://medium.com/@olamishina/building-ux-for-error-validation-strategy-36142991017a?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/36142991017a</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[validation]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Tue, 04 Apr 2023 21:14:40 GMT</pubDate>
            <atom:updated>2023-04-27T19:22:32.144Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w8vbrI4xW6zNEiNR06RGCg.png" /></figure><p>Error validation strategies are often neglected in the product design field, despite being crucial to ensuring a smooth user experience. While many designers understand the importance of well-designed “Sign In” and “Sign Up” pages with fully-covered username and password validation cases, a more in-depth and big-picture approach for the entire system is often overlooked. Although there is no shortage of information available on the importance of error validation types and patterns, building a comprehensive strategy for a large, complex product can be daunting. This can lead to anxiety, uncertainty, and many questions:</p><ul><li>Where should we begin?</li><li>How can we create a cohesive and safe solution for the entire system?</li><li>And perhaps most importantly, how can we effectively execute and maintain this strategy?</li></ul><h3>My story</h3><p>As the lead product designer, I faced a significant challenge when transitioning the product from legacy code to new technology for the entire ecosystem. Despite a tight deadline and no access to users and analytics, my objective was to develop and execute a digital “happy path” that prioritized error prevention and recovery as a strategy.</p><p>The product was complex, comprising various services within the ecosystem, including the Service Management Platform (SMP) — a critical platform for admin users to manage system setup, entities and objects, users, permissions, feature enablement and workflows, as well as access and data governance controls across other applications. SMP is common for B2B applications and SaaS and is organized in terms of Information Architecture as a set of Entity List views and <strong>Object Configuration forms</strong>.</p><p>We understood our Admin Persona and their tasks primarily involve performing CRUD (create-read-update-delete) operations within entity objects. Each action served a specific purpose in managing the overall product, and a lot of activities occurred in <strong>Object Configuration form</strong>.</p><p>Our team recognized the need to implement a robust validation strategy with no room for failure or significant improvements post-implementation. It was a now-or-never challenge that demanded our best effort.</p><p>Let’s begin.</p><h3>Part 1: Research</h3><p>I’ve researched inline form validation extensively and gathered valuable insights I’d like to share with you. While I’ll provide a brief summary and key takeaways, I strongly recommend reading the articles I’ll be linking below for a more comprehensive understanding.</p><p>To make the information more organized and accessible, I’ve categorized it into three blocks for a well-rounded perspective:<br>1. Accessibility.<br>2. UX.<br>3. Development.</p><h4>Block 1: Accessibility</h4><p>If you are not ready to read the complete documentation, save it for later. But I urge you to consider the following part at least:</p><ul><li><a href="https://www.w3.org/TR/WCAG21/#error-identification">WCAG guideline “3.3 Input Assistance”</a> (3.3.1 to 3.3.6)</li></ul><p>Here are <strong>the main takeaways</strong>:</p><p>✅ Always identify and describe errors to the user when they occur, and provide a solution to fix the error if possible. A standard approach is highlighting the field border in red and including a placeholder for the error text. This is a widely-used pattern that works well for most cases.</p><p>✅ Provide a clear visual indicator when user input is required. The most typical pattern for this is using an asterisk “<strong>*</strong>” to mark required fields or labeling them with the word “<strong>required</strong>”. However, be careful not to overload the user with too many indicators. Keep it simple and clear.</p><h4>Block 2: UX</h4><p>I would like to recommend reading the following excellent articles to dig deeper:</p><ul><li><a href="https://baymard.com/blog/inline-form-validation#pitfall-1-premature-inline-validation">Usability Testing of Inline Form Validation Study</a> by Christian Holst (Baymard Institute)</li><li><a href="https://www.smashingmagazine.com/2022/09/inline-validation-web-forms-ux/#comments-inline-validation-web-forms-ux">A Complete Guide To Live Validation</a> UX by Vitaly Friedman</li><li><a href="http://alistapart.com/article/inline-validation-in-web-forms/">Inline Validation in Web Forms</a> by Luke Wroblewski</li><li><a href="https://www.nngroup.com/articles/hostile-error-messages/">Hostile Patterns in Error Messages</a> and <a href="https://www.nngroup.com/articles/errors-forms-design-guidelines/">How to Report Errors in Forms: 10 Design Guidelines</a> by Rachel Krause (Nielsen Norman Group)</li><li><a href="https://www.smashingmagazine.com/2023/02/guide-accessible-form-validation/#moments-of-validation">A Guide To Accessible Form Validation</a> by Sandrina Pereira, Staff Frontend Engineer</li></ul><p>After reviewing various sources on the topic, I’ve distilled <strong>a few critical considerations</strong> for UX designers:</p><p>✅ Familiarize yourself with the different patterns of validation: <strong>AFTERWARD</strong> (“on blur” in technical speak), <strong>WHILE </strong>(“on key press”), <strong>BEFORE AND WHILE </strong>(“on blur and on keypress”), <strong>SUBMIT </strong>(clicking on “Submit” or “Save” button).</p><p>✅ Avoid premature validation and only display error messages after an error has been made.</p><p>✅ Validate empty fields (required) only on submit to avoid interrupting the user’s flow.</p><p>✅ Use AFTERWARD (on blur) validation for optional fields.</p><p>✅ Make it easier for the users when possible, such as by allowing multiple inputs separated by commas or periods.</p><p>✅ Prioritize displaying severe errors sooner rather than later, but ensure the interruption is appreciated.</p><p>✅ Avoid disabled buttons and instead allow users to click buttons at any time, displaying error messages with instructions.</p><p>✅ Consider auto-focusing invalid inputs, particularly for long configuration forms, so the user doesn’t need to navigate to them manually.</p><h4>Block 3: Development</h4><p>Now let’s talk about development. While it may not be a designer’s area of expertise, it’s essential to have a basic understanding to ensure the system is feasible and stable while meeting HTML requirements and recommendations.</p><p>I recommend reading the following articles to gain insight:</p><ul><li><a href="https://developer.mozilla.org/en-US/docs/Learn/Forms/HTML5_input_types">The HTML5 input types</a> and <a href="https://developer.mozilla.org/en-US/docs/Learn/Forms/Form_validation">Client-side form validation</a> by Mozilla</li><li><a href="https://www.the-art-of-web.com/html/html5-form-validation/">HTML5 Form Validation Examples</a></li></ul><p>As a recap, UX Designer should consider here the following:</p><p>✅ Client vs. Server validation. Validation done in the browser is called client-side validation (AFTERWARD, WHILE, BEFORE AND WHILE), while validation done on the server is called server-side (upon “Submit”) validation. It’s essential to communicate with developers to determine when client or server validation is appropriate, as some validation can only be done on the server side, such as uniqueness and special data formats for some cases. Forcing client-side validation over server-side validation can result in poor performance and potentially compromise the system’s security and architecture.</p><p>✅ Understanding the basic input types and their parameters in HTML5 can help to accelerate design decisions and ensure that the experience aligns with development requirements. Common validation attributes, such as “required”, “minlength”, “maxlength”, “min”, “max”, “type”, and pattern, should be taken into consideration when designing the user input rules.</p><h3>Part 2: Gathering product requirements</h3><p>Now that we’ve completed our research, it’s time to gather the product requirements and see the big picture. This is where we could collaborate with our product manager to identify what user data we need and which format to collect across the system&#39;s various entities.</p><ul><li>Begin with the basics, such as User name, Address, Email, Password.</li><li>Consider any restrictions on input, such as character limits or format validations.</li><li>Look out for fields that require cross-validation attributes. For example, some fields may need a minimum length and a specific format validation.</li><li>Identify which data is required (mandatory) for input.</li></ul><p>Predicting the future can be challenging, and teams may struggle with forward-thinking. But that’s okay! We don’t need to come up with the exact set of fields for each entity. The goal is to understand and capture the broader perspective as much as possible. At the end of this exercise, we should have a draft list of possible user data input with corresponding requirements and restrictions.</p><p>If your team challenges to do this exercise, you could ask for Chat GPT assistance. Just give him the brief product details and request to come up with possible fields for user input. See the results below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*FKRFCX6H_67FWuPK8Fn6FA.png" /><figcaption>Sometimes Chat GPT can give you a hand.</figcaption></figure><p>While the initial concept is promising, there are some improvements we can make to tailor it more closely to our product’s needs and ensure clarity. After some adjustments, the concept can take the form shown in the image below, which we can bring into the next phase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JeWe050N0tfb4Z75Bne7iQ.png" /></figure><h3>Part 3: Testing research takeaways</h3><p>In order to evaluate the insights gathered from our research, we will create an imaginary form for a New User configuration that includes all the fields from our previous phase, imagining <strong>the worst-case scenario</strong> with the most complex possible structure. This exercise will help us determine the appropriate layout, design of text fields, and placement of error messages.</p><p>We will conduct three tests to assess our research assumptions collectively, with each test encompassing multiple assumptions.</p><ul><li>Test 1: Enabling “Save” button and displaying errors for required fields upon submit.</li><li>Test 2. AFTERWARD validation.</li><li>Test 3. Exploration of different validation patterns altogether.</li></ul><h4>Start point</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1vtUpxevEF5hLbFFYqlNVA.png" /><figcaption>Imaginary worst-case scenario of the user configuration form.</figcaption></figure><p>I’ve put together all of the fields we listed in the previous phase. Also, I add more inputs to make it closer to reality just a little in order to add complexity. This concept layout features components from our company’s design system.</p><p>At this stage, I am good with how it looks so far. Let’s start to test it!</p><h4>Test 1: Enabling “Save” button and displaying errors for required fields upon submit</h4><p>This GIF demonstrates a scenario in which all required fields are left empty, and the validation message appears upon clicking the “Save” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nHdA6lyuG2_rubF_CtssyA.gif" /><figcaption>Examining the validation of required fields upon submit in the prototype.</figcaption></figure><p>But as we begin validating one assumption, more questions arise. Let’s take a moment to review our progress.</p><p>✅ Enabling the “Save” button and validating required fields upon submission is a strong approach. It helps prevent premature error messages and reduces user anxiety when the primary button is disabled without indication.</p><p>✅ Alongside the main objective, we also had to tackle the question of how to display error messages on the UI. For our product, we agreed to use a two-column layout as it allows for more data to be displayed on one screen, which is crucial for our personas. When it comes to handling error messages in this layout, I always prioritize creating an unbreakable and solid UI that can respond to dynamic content. In the case of error messages, I recommend not limiting the message height and wrapping the text if it’s too long, considering the possibility of translation copy into different languages. Moreover, I decided to shift upcoming errors below within the whole row as the content is organized from left to right, top to bottom direction, and breaking the column could throw off the balance of the organization.</p><p>✅ I suggest implementing a common behavior where the error message disappears once the user fills in at least one character. This approach would enhance the user experience, and users wouldn’t be bothered with error messages once they start filling in the required fields.</p><p>Overall, I am satisfied with the results of this test, and I think we can proceed to examine the other assumptions.</p><h4>Test 2: AFTERWARD validation</h4><p>This test showcases a scenario where all fields fail validation due to different restrictions, and the appropriate error messages appear, followed by an AFTERWARD validation pattern.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OFXBy1aoSh8uSQAbe8e9ZA.png" /><figcaption>Examining the AFTERWARD validation gathered all together in one mock.</figcaption></figure><p>This design needs improvement as it appears cluttered and overwhelming for a single view, even though it is an edge case. Furthermore, the experiment highlights that the user may suffer and lose focus quickly.</p><p>Let’s think about preventing user mistakes and improving the readability and neatness of the UI. In the next iteration, we need to address the following gaps:</p><p>⚠️ Profile and Media. The error messages are not clear due to limited space. We need to revise the UI to provide more specific error messages and clear solutions for the user to fix.</p><p>⚠️ First and Last names, Company, and Designation fields. My assumption here is that showing this validation for such inputs could be redundant. Is this necessary to know for the user precisely limit value? What if we can prevent user mistakes?</p><p>⚠️ Email field. Oops, a case with email confirmed status seems missing here and wasn’t executed.</p><p>⚠️ Description field. My hypothesis here is to keep the error message. We anticipate that users may enter longer content and value the effort users put into filling out forms. In addition to this, we can complement this field with a character counter. Thanks to Twitter, this feature is already popular as it helps users understand how many characters they have left.</p><p>⚠️ Password fields. The plain text of the error message gives no clue about the exact errors that the user possibly made. It would be beneficial to consider implementing interruptions earlier to prevent user mistakes.</p><p>⚠️ User rank and Date range fields. My assumption here corresponds with the one I brought for inputs max length validation. We could add logic that prevents users&#39; mistakes here, especially from selecting an end date preceding the start date.</p><p>Other fields I didn’t mention look appropriate to me. Let’s continue.</p><h4>Test 3: Exploration of different validation patterns altogether</h4><p>How does uniqueness look with the required field if both validate on submit?</p><p>An ideal candidate to examine this is the email text field:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qRZyeYHFZnfXuKJK2kyY5g.gif" /><figcaption>Examining different validation patterns in one field: Email.</figcaption></figure><p>✅ I think this behavior contributes to our goals, is aligned with the overall logic, and still keeps clear feedback for the user.</p><p>Across the board, I’m satisfied with the design system components and validation behavior we’ve checked. While there may be some minor issues with overlapping error messages, the system prevents users from saving the form until all errors are resolved, ensuring they don’t miss critical information. This behavior seems like a safe solution to me, and we are good to go.</p><blockquote><strong>Tip 1.</strong> Brainstorm all the scenarios that need to be tested before making a final decision. Create prototypes and explore them thoroughly, as demonstrated in the examples provided.</blockquote><blockquote><strong>Tip 2</strong>. Don’t hesitate to share your first design iteration with your developers, even if you’re unhappy with it. They can provide valuable insights that you can evaluate during the second round of design.</blockquote><h3>Part 4: Second iteration</h3><p>After addressing all the gaps identified in the previous round, I have implemented a more or less final layout that addresses all the issues raised in “<strong>Test 2: AFTERWARD validation”</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*75YoA8nwUyBg3At569Se8A.png" /><figcaption>Examining the reworked version.</figcaption></figure><p>Contemplating all factors, I believe we are in an excellent position to move forward. Here are my reflections and results of the second iteration:</p><p>✅ Profile and Media. I decided to keep the same content organization and transitioned the error message to a toast notification. Although debatable, this input mechanism can be treated differently, and the design solution doesn’t change the layout significantly. <strong>However, be careful since this solution might not work well if you approach attachments within a modal window.</strong></p><p>✅ First and Last names, Company, and Designation fields. Single-string text fields with length restriction (character limitation) will be validated with the WHILE pattern in hidden mode, and input will be disabled once the limit is exceeded. According to the product manager and boarding team insights, long text in such inputs is rare.</p><p>✅ Email field. We add an exceptional case for email validation to warn the user whether the email is confirmed. This will be treated as SPECIAL validation, and it won’t overlap with error messages if the user decides to change it.</p><p>✅ Description field. Characters counter will be displayed when needed for massive text area fields.</p><p>✅ Password fields. It’s safest to check in real-time (the WHILE pattern) and provide instant and relevant feedback to prevent user errors by guiding her/him through the input checklist requirements.</p><p>✅ User rank and Date range fields. We will disable input behind the scenes using the WHILE pattern in a hidden mode for min/max value validation. For instance, in the date range picker, we will prevent the user from selecting an end date earlier than the start date and reset the input if manually entered incorrectly.</p><h3>Part 5: Results and documented strategy</h3><p>It’s time to summarize everything and create explicit rules and guidelines for in-product error validation strategies. By following these guidelines, we aim to establish a consistent and user-friendly approach to error validation across all areas of our product.</p><p>Our documentation of the validation patterns and error messaging guidelines will be an essential resource for our design, development, and product teams, helping to ensure that all new features and updates follow the established standards.</p><h4>Part 1: Documented Validation patterns</h4><p>Here are the overall view and explanations of validation patterns we’ll be implementing in the product:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*udfypDu0dbXlrOeRjM_Huw.png" /></figure><p>As you may notice, I’ve added two options for the WHILE pattern:</p><ul><li><strong>Option A: Visible.</strong> For example, this option is suitable for password validation, where it is crucial to provide instant feedback.</li><li><strong>Option B: Hidden.</strong> This option is suitable for text fields where error messages should not be displayed. Instead, we will disable the input behind the scenes to prevent errors. An example of this is text fields with character limitations.</li></ul><h4>Part 2: Documented validation kinds and error message templates</h4><p>In order to fully document our validation approach, we will compile a detailed list of all validation types and their associated patterns, alongside a standardized error message template for consistent messaging.</p><p>We may also incorporate visual aids, such as snapshots or examples, to provide additional clarity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rh6uX7F0gdq8ahoSGt2HSA.png" /></figure><p>This document will serve as the authoritative source for others and set the pattern for future steps. When all the rules and examples are consolidated in one place, it becomes effortless to maintain a consistent UX copy for error messages.</p><p>Otherwise, if no such document exists, we may end up with a plethora of messages for required field validation, such as “This field is required”, “This field cannot be empty”, “This field is empty, please fill it”, and so on.</p><h4>Part 3: Documented UI specs</h4><p>Don’t forget about the user interface! Make sure to provide detailed specifications for all design system components. This will guarantee that your team can consistently implement the correct visual and interactive elements throughout the product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*HtbaIwYRuMnm0QHv25fesg.png" /></figure><h4>Part 4: Documented in page data validation template</h4><p>Last but not least, let’s explore an example of how to use the framework in practice. When it comes to building a precise layout, such as a User Configuration Form, you can analyze all attributes and convert them into the following format:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zKmOjzEUDxYmGHkCYdUM9A.png" /></figure><p>This document is essential as it will comprehensively list all the fields and their respective validation requirements, including the exact wording for error messages.</p><p>Trust me, this will be highly beneficial for everyone involved in the product development process. It will provide a clear and concise framework for utilizing the validation patterns and provide consistent implementation across the board. Additionally, it will significantly assist QA in reviewing the page by referencing this description document.</p><p>Now you are ready to go and share it with the team!</p><h3>Summary: What’s left to consider</h3><ul><li>It’s normal for some decisions to be debatable.</li><li>This guide should give you an idea of the approach you can test in your product. Remember that the validation strategy may differ depending on the product type, intended audience, deadlines, budget, and overall product strategy.</li><li>Submit button placement: configuration forms in SaaS products can be lengthy and complex, with “Save” and “Cancel” buttons sometimes placed at the very top or bottom. This can force users to scroll to reach the Submit button, causing unnecessary stress. To alleviate this issue, assume designing a fixed, scroll-independent bar with action buttons at the bottom that’s always available in the user’s view.</li><li>It deserves a separate article if your configuration forms involve complex nested navigation. When it comes to cross-tab validation, it can get tricky. Be mindful of how the system should react if the user navigates between tabs and encounters errors.</li></ul><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please 👏 so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=36142991017a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creating Designs that Developers Love: Tips for Effective Collaboration]]></title>
            <link>https://medium.com/design-bootcamp/creating-designs-that-developers-love-tips-for-effective-collaboration-f47b706e13bc?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f47b706e13bc</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[collaboration]]></category>
            <category><![CDATA[design-handoff]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Sun, 05 Mar 2023 22:00:43 GMT</pubDate>
            <atom:updated>2023-04-04T21:16:21.813Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Meme illustration showcasing a designer saying: “We can create an insane design,” and a confused developer standing on the back." src="https://cdn-images-1.medium.com/max/1024/1*gGgc1ZTfvSPnq6Kh0WNlJg.png" /></figure><p>Designing complex interfaces is not just about creating visually appealing designs but also ensuring developers can implement and maintain them effectively. However, developers often have numerous questions or concerns when implementing the designs despite providing instructions. This can be a frustrating experience for designers, and it can lead to unnecessary delays in the project timeline.</p><p>Imagine this scenario: you hand off your designs to developers, and suddenly, you’re bombarded with questions like:</p><ul><li>“What will happen if this data is too long?”</li><li>“These design solutions don’t fit in one sprint.”</li><li>“What is this component? It looks slightly different than our Single Select in Storybook. Should I create a new one?”</li><li>“We are not able to show search results on on-the-fly as in your mockup.”</li><li>“I don’t think we could do this animation.”</li></ul><p>If this scenario sounds familiar, stay here with me. I’m excited to share some tips and techniques with you, that I wish I knew earlier. These tips can help you reduce potential uncertainties and build a ready-to-be-implemented, solid UI that will make your developers happy.</p><p>So, keep reading!</p><h3>Communication</h3><figure><img alt="Screenshot of my top groups of conversations in Slack: Devs and QAs." src="https://cdn-images-1.medium.com/max/1024/1*3MBgoncUUrZnZ2OIWuXFNg.png" /><figcaption>Screenshot of my top groups of conversations in Slack</figcaption></figure><ul><li>Communicate regularly and build strong relationships with front-end developers and QA engineers. They should be your go-to contacts throughout the design process.</li><li>Involve developers in the design process from the beginning. This will help you identify any potential technical limitations or roadblocks early on, and ensure that your design fits the current architecture decisions.</li><li>It’s important not to underestimate the expertise of QA engineers. They deeply understand the system and its settings, which can be instrumental in catching potential gaps in your designs. For example, missing areas can be highlighted, such as overlooked user permissions or UI changes that could be affected by other enabled settings.</li></ul><blockquote>If your team doesn’t follow any popular project management methodology which implies regular cross-team syncs and meetings, you should initiate them yourself!</blockquote><blockquote>When you’re ready to hand off your designs to development, do a project kick-off for QA engineers and front-end developers. This will help guarantee that everyone is aware of future direction and allow you to focus on key points and areas that should be tested.</blockquote><h3>Design execution and delivery</h3><h4>Files organization and links</h4><figure><img alt="The split view that is showcasing two approaches of In-file mockup organization. The first approach is when a designer shares a link with Dev to final designs and redirects you to a mess inside a file: hundreds of mockups without any clue when the start point is and what the case is. And the second approach is when a link navigates you to the exact place to the well-organized mockups, and everything is straightforward and clear." src="https://cdn-images-1.medium.com/max/1024/1*PvYKnwpInVq8xORXfhYCEg.png" /></figure><p>Try to be loyal and respectful to others. This means providing links to specific and accurate places in your designs and structured flow diagrams when sending them to developers or attaching them in Jira. Doing this saves developers the time they would otherwise spend searching through a cluttered mockup mess.</p><p>Additionally, it’s important to keep a clear and consistent naming hierarchy across your files and layers to ensure that everyone can easily understand the structure of your designs.</p><h4>Version control</h4><figure><img alt="The image illustrates a case when a design file has multiple versions. Developers are frustrated and can’t understand which are the latest and up-to-date." src="https://cdn-images-1.medium.com/max/1024/1*ufy1LjAgkWlc4ZDMRuSZ8A.png" /></figure><ul><li>It’s essential to assure that your final designs are not suddenly overwritten or changed when implementation or testing has already started. To avoid this, it’s crucial to implement version control measures to keep track of design iterations and changes.</li><li>If you need to change something immediately in a mockup or a component, because requirements were reconsidered, document this change in the associated developers’ ticket and inform all assigned to this task colleagues directly.</li><li>To avoid confusion, keep your design separated or unlinked from the components library, especially if components are still in progress and can affect the current implementation and designs that have already been agreed upon and committed.</li><li>If your design tool has the possibility to generate a link that relates to a particular timestamp in the past, attach this link to the ticket to help track design changes and iterations more efficiently. For example, Sketch has a “Share” feature that allows you to generate a link to a specific version of your design.</li></ul><h4>Assets export</h4><figure><img alt="The image illustrates assets exports example by showcasing a ‘trashbin’ icon export in three sizes: 1x, 2x, 3x." src="https://cdn-images-1.medium.com/max/1024/1*Jss0Q1sCkfTP_UV3y3rFHw.png" /></figure><p>When exporting assets, it’s important to keep in mind the technical requirements and constraints of different devices. Take the time to review the guidelines and ensure that all images and icons are exported in the appropriate resolution and format. For example, when designing for iOS, don’t forget to consider retina displays and export images in different dimensions for mobile apps. It is easy nowadays since thousands of <a href="https://www.figma.com/community/plugin/818009596569137328">plugins</a> and add-ons can accelerate this procedure.</p><p>If you are crafting icons/illustrations only for web-based apps, figure out the format developers prefer to work with. Discuss with the development team whether they prefer using icons in .svg format or created icons font. If you are curious about icon font and want to know more, I recommend reading <a href="https://blog.adobe.com/en/publish/2017/11/15/weekoficons-prepare-svg-icons-for-icon-fonts">this article</a>.</p><h4>Breakpoints and device compatibility</h4><figure><img alt="The image illustrates breakpoints variety depending on a device type: desktop, laptop, tablet (landscape vs. portrait views), and mobile phone." src="https://cdn-images-1.medium.com/max/1024/1*f-QEYlCBxovwpzioeY8D6g.png" /></figure><p>Your designs should be well executed for various devices and screen resolutions. To achieve this, I recommend documenting “responsive” layout rules that can be applied across your system and all its pages.</p><p>Apart from that, shifting to a mobile-first mindset can help you create designs optimized for smaller screens and easily scaled up to larger ones. This approach also allows you to prioritize your design&#39;s essential features and content, ensuring a better user experience across different devices. If you need to dive deeper here, please navigate to <a href="https://ishadeed.com/article/responsive-design/">this article</a>.</p><h4>Dynamic content</h4><figure><img alt="The split view showcases a best-case scenario mockup and a cruel reality scenario. Best-case scenario mockups don’t include and cover the case when content could be dynamic so that the text can be extra significant and not fit inside the associated place. So what will the UI look like? A cruel reality example shows that data can go out of the container and break a layout when this thing doesn’t establish and the rule hasn’t been articulated to devs." src="https://cdn-images-1.medium.com/max/1024/1*SpRikB7LDyIOoQ8rsVqzuw.png" /></figure><p>Evaluate the dynamic nature of the content. Keep in mind that the content length may vary, and design accordingly. Make sure that there is enough space for longer text and that the design can adapt to accommodate different types of data.</p><p>Basically, every time you are dealing with elements that could possibly have random data inside (users input, back-end message), think about the following items:</p><ul><li>For short and concise user-generated data, such as in plain lists, limit the visible text and add an ellipsis, with a tooltip on hover to display the full content.</li><li>For longer texts that are important for user experience, you could wrap text and adapt the width/height of the container to fit the content while ensuring a maximum to avoid broken UI.</li><li>For giant text, consider using expand/collapse controls for the data preview if it fits the user’s needs.</li><li>Do not be afraid to combine these methods below to achieve your goals. Just remember that you need to provide the worst UI scenario of any approach you choose for developers.</li></ul><blockquote>Showcase how long texts and a vast amount of records look on a full page view or in a modal window. Always include horizontal and vertical scroll bars to indicate where the they should be placed.</blockquote><h4>Popovers</h4><figure><img alt="The split view demonstrates two different approaches to displaying calendar popovers when they are located at the very bottom of a page. In the first view, the popover extends beyond the edge of the screen, making it difficult for the user to interact with. The second view offers a solution to this problem by calculating the available space for the popover to open each time, ensuring that it always appears fully within the user’s viewable area." src="https://cdn-images-1.medium.com/max/1024/1*xvqi4Z--WOiOH4FsR69QnA.png" /></figure><p>Popovers are a widely used UI element that appears when a user interacts with specific elements such as tooltips, context menus in dropdowns, calendars in date pickers, and more. One important rule that some designers tend to overlook when designing popovers is always to check if there is enough space for the popover to appear and display it on the side with sufficient space.</p><p>This may seem like an obvious rule, but it is important. For example, if a popover appears on the wrong side due to insufficient space, it could overlap with other elements or even get cut off, leading to confusion or frustration for the user.</p><h4>Design specs</h4><figure><img alt="The split view showcases two different methods for handing off design component specifications to developers. In the first view, a single mockup is provided that showcases the best-case scenario, along with a screenshot of the auto-layout properties from Figma. In the second view, a more in-depth specification is provided that includes details such as margins, paddings, and dynamic content scenarios that speak the same language as CSS." src="https://cdn-images-1.medium.com/max/1024/1*6cGa8EQgII_Zm14R8PVAkg.png" /></figure><p>When sharing design specs with developers, it’s important to communicate in their language. Don’t assume that developers are experts in your design tool of choice.</p><p>For example, many developers may not know how you’ve set up your component with auto-layout in Figma. Instead, provide component and layout specifications showcasing component behavior and anatomy in terms of CSS properties for specific divs or elements. If you don’t feel confident in this field, <a href="https://app.uxcel.com/courses/css-for-designers/intro-to-css-935">explore it more</a> and observe the browser console CSS, so you can better understand how developers see the content on the page and provide more accurate design specs.</p><h4>Cases and page states</h4><figure><img alt="The image provides examples of four corner cases that designers may overlook when designing user interfaces. These cases include the page empty state, error handling, and 4xx and 5xx errors." src="https://cdn-images-1.medium.com/max/1024/1*TCqJiPe47BA6whHqUWslDQ.png" /></figure><p>While it’s easy to focus on the ideal scenario or the “happy path,” it’s important to plan when things go unexpected.</p><p>For example, what happens when a user submits a search query with no results? Or what if there’s a connectivity issue that prevents the page from loading properly? You can create more resilient and user-friendly designs by considering these edge cases.</p><p>Taking the time to cover all scenarios will reduce the appearance of bugs and limit the number of users reaching out to support for assistance.</p><blockquote>Do not forget to design error pages for all 4xx and 5xx error status.</blockquote><h3>Design System</h3><h4>Design System?</h4><figure><img alt="The image depicts an arm-wrestling starting point, with one hand labeled as “Devs” and the other labeled as “Designers”. In the center of the image, there is a caption that goes for “Design system”." src="https://cdn-images-1.medium.com/max/1024/1*bpKTX_HCplqk5k0e46YDXg.png" /></figure><p>This is not a topic of this article, but If your team doesn’t have a design system, it’s worth considering implementing one. If you already have one, congratulations!</p><p>By Design System, nowadays, I mean a <a href="https://rangle.io/blog/before-design-systems-visible-consistent-and-changeable-components">Storybook</a>, which is an industry-standard UI documentation tool. It helps to highlight UI pages, components, tokens, and rules. By exploring each input variation that controls a configuration, the user can understand how a component is used or how a page works.</p><h4>Component properties</h4><figure><img alt="The image showcases two different approaches to designing component states, including enabled, hover, pressed, disabled, etc. The first approach results in inconsistent component sizes, with varying dimensions depending on the state of the component. In contrast, the second approach maintains a consistent and straight design, with a common container size that remains the same across all states." src="https://cdn-images-1.medium.com/max/1024/1*YoNo1EXJioMJrhV5KHt74w.png" /></figure><p>When designing components, coherence is just as important as simplicity. For instance, if you have an icon button that is 16x16 for the enabled state and 24x24 for the hovered state, it’s better to provide a consistent size for all states of your component. This makes it easier for developers to implement it quickly without resorting to workarounds.</p><p>In addition, it’s critical to ensure that your components are closely linked to all relevant tokens and aligned with established design rules. If your team doesn’t have any design rules in place, I highly recommend exploring the topic of Design Systems separately.</p><h4>Component duplicates</h4><figure><img alt="The image displays two contrasting views of button design. In the first view, many buttons are shown that look similar to each other, but have subtle differences in size, font styles, heights, and other visual attributes. In contrast, the second view shows only two buttons: primary and secondary. This approach prioritizes simplicity and clarity, with a focus on creating buttons that are easy to use." src="https://cdn-images-1.medium.com/max/1024/1*TH0FySJX27DrU693VomGtg.png" /></figure><p>Avoid creating multiple components that perform the same function but look different. Instead, be aware and curious about what components live in a Storybook and reuse them. This approach saves time and effort and ensures consistency across your design system.</p><h4>Custom components</h4><figure><img alt="The image depicts two different approaches to custom component implementation, using the example of a multiselect component. The first approach shows a large design specification that covers all possible interaction scenarios and keyboard control uses. The second approach involves using a ready-to-use solution from an open-source library. This approach may involve less design and development work, as the component is already available and can be easily integrated into the product." src="https://cdn-images-1.medium.com/max/1024/1*TFcp04gOpznkkF3Ff8jZxQ.png" /></figure><p>Have you ever found yourself designing a custom component from scratch, only to realize it was a waste of time and resources? I certainly have. At one of my previous companies, we spent several months developing a custom multi-select component with search functionality, advanced keyboard controls, and chips. We thought we were creating the ideal component, but we got lost in generating and polishing all the possible use cases. It turned out that we had invested a lot of time and effort into a task that ultimately had no real measurable benefits.</p><p>I wish someone had stopped me and shown the select2 component at the time. It would have saved us a lot of headaches and resources. That experience taught me the importance of checking for existing solutions before starting any custom component design. Not only does it save development time, but it also ensures that the component is maintainable and adjustable in the long run.</p><p>Remember, sometimes the best solution is the one that already exists. So before embarking on any custom component design, do research and collaborate with your team to find the most suitable solution.</p><h3><strong>Technical limitations</strong></h3><h4>Framework</h4><figure><img alt="Mentioning the most popular options, React, Angular, Vue, Ember, and jQuery are common for front-end development, while Django, Ruby on Rails, Laravel, Spring, and Express are often used for back-end development." src="https://cdn-images-1.medium.com/max/1024/1*YHUm8Eb7A2F8NOLxLKeFHA.png" /></figure><p>Having a basic understanding of the one your developers use can improve collaboration and lead to better design solutions. This knowledge can also help you avoid designing something that isn’t feasible or that requires extensive modifications.</p><h4>Protocol differences</h4><figure><img alt="HTTP2 and HTTP1.x protocols schemes that explains shortly how they work. HTTP1.x is an older protocol that uses separate connections for each request/response pair. In contrast, HTTP2 uses a single, persistent connection and a binary format for data transmission." src="https://cdn-images-1.medium.com/max/1024/1*P9-m5dvaWB4icqsCnMEWmw.jpeg" /><figcaption><a href="https://coolicehost.com/http2-protocol.html">Image source</a></figcaption></figure><p>HTTP2 and HTTP1.x protocols dictate how data is transferred between a server and client, which can impact the performance of your website or application. To optimize your design for better performance, identify which protocol your system uses and adjust accordingly.</p><p>For instance, if your system uses HTTP2, you don’t need to worry too much about providing visual assets separately to front-end developers. However, if you’re working with HTTP1, it’s best to hand off all images as a single view, or atlas, so that the developer can slice them into pieces.</p><h4>Data disposition</h4><figure><img alt="This infographic shows the difference between Synchronous and Asynchronous data distribution methods. Synchronous refers to a method where data is transmitted in a consistent and predictable order, with each step waiting for the previous step to complete before moving forward. On the other hand, asynchronous data distribution allows for data to be transmitted and processed independently without the need for strict synchronization between steps." src="https://cdn-images-1.medium.com/max/1024/1*7w-layG4m7leOscoMI31Tg.png" /><figcaption><a href="https://www.scaler.com/topics/synchronous-and-asynchronous-javascript/">Image source</a></figcaption></figure><p>Consider the way data is disposed in your architecture: whether it’s synchronous or asynchronous. This understanding can help you create not only efficient and user-friendly experiences, but also feasible ones.</p><p>For example, you might think of building a table with lazy loading instead of pagination. However, it’s important to weigh the potential costs of this approach, such as the need for additional developer resources that can potentially increase the project timelines.</p><p>One more popular example is designing a search possibility for high-loaded database “on the fly”. Searching through a vast number of records in real-time can be resource-intensive, especially when it involves complex calculations or data manipulations. In such cases, it’s more efficient to trigger the search only when the user initiates it, such as by clicking a button or pressing “Enter” rather than doing it “on the fly”. This approach can prevent performance issues and ensure a smoother user experience.</p><p>Be thoughtful and rational when evaluating these trade-offs and considering the current architectural approach.</p><h4>Simplicity</h4><figure><img alt="The image depicts a mockup of an imaginary website with a cluttered and overwhelming user interface. The website features numerous animations, images, and other visual elements, as well as unclear navigation and a lack of visual hierarchy and coherence." src="https://cdn-images-1.medium.com/max/1024/1*9WPCTwV0Yzr95UWTsiW1ow.png" /></figure><p>The more simple UI is, the better the performance. I know it is pretty obvious, but do you understand exactly what it means?</p><p>This means avoiding complex animations, nested popups, and design decisions that could create more corner cases. It’s important to prioritize functionality over flashy design elements and to consider how design decisions could impact website performance and development time. If animations are necessary, it’s essential to carefully prioritize which ones to use and how to implement them in a way that doesn’t hinder performance. You could explore by yourself <a href="https://web.dev/animations-guide/">which animations you should avoid</a>.</p><blockquote><strong>Important !!!</strong></blockquote><blockquote>Remember, your mockups are just images until they are released on production, so make sure to take the necessary steps to ensure that they come to life as intended.</blockquote><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please 👏 so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f47b706e13bc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/creating-designs-that-developers-love-tips-for-effective-collaboration-f47b706e13bc">Creating Designs that Developers Love: Tips for Effective Collaboration</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering CRUD Operations: a Framework for Seamless Product Design]]></title>
            <link>https://medium.com/design-bootcamp/mastering-crud-operations-a-framework-for-seamless-product-design-2630affbc1e5?source=rss-f2d5b8fdb65b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2630affbc1e5</guid>
            <category><![CDATA[information-architecture]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[usability]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Ola Mishina | Lead Product Designer in CCaaS]]></dc:creator>
            <pubDate>Sun, 19 Feb 2023 20:51:27 GMT</pubDate>
            <atom:updated>2023-04-04T21:18:38.337Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="The CRUD acronym stands for the Create, Read, Update, and Delete operations, which are complemented by associated icons: a plus sign for Create, an eye icon for Read, a pencil icon for Update, and a trash bin or garbage can icon for Delete." src="https://cdn-images-1.medium.com/max/1024/1*DI5wwLcQV-b3erfLIbvfFQ.jpeg" /></figure><p>As a product designer, when you prototype the foundation for the content organization in Web-based software, it’s necessary to examine the standards and guidelines for developing and managing persistent data elements.</p><p>In this article, I will walk you through the basics of CRUD operations and its design framework, providing a helpful starting point for product designers to incorporate into their work.</p><blockquote>This information could be helpful for product designers, product managers, QA engineers, and front-end developers.</blockquote><h3>CRUD: Create, Read, Update, Delete</h3><p>The CRUD heuristic, which stands for Create, Read, Update, Delete, originates from relational databases. These four actions form the fundamental operations that can be performed on data within a table. Sometimes, when a software application serves mainly as a means to input and output data from a database, it may be referred to as a “basic CRUD application.”</p><p>But CRUD is not just about databases. It is also a central concept in applications&#39; user interface design, allowing users to manipulate and alter their data. For example, a CRUD-based UI might use forms and reports to read, create, update, and delete objects, such as users, customers, orders, or products.</p><p>CRUD is a fundamental concept that bridges the gap between database management and user interface design. By understanding the basic principles, designers can create coherent, functional, reliable, and user-friendly applications.</p><h3>Preparation: Terminology &amp; layout essentials</h3><p>When considering the big picture of software information architecture, it’s significant to clearly understand the terminology used to refer to specific data elements within the system. To ensure clarity throughout this article, I will use the term “entity” to refer to a class of objects, while “object” will refer to a specific record within an entity. For example, we might have an entity called “Users”, with individual objects representing users such as “John Smith”, “Sara Black”, “Tom Cruise”, etc.</p><p>When it comes to designing a page for a specific entity in the system, the following components are typically included in the layout:</p><figure><img alt="Basic layout example showcasing the UI for list view. It consists of headline, CTA button, search bar and table with object rows." src="https://cdn-images-1.medium.com/max/1024/1*goxItqQJwC5JOngD_JgxsQ.png" /><figcaption>Basic list view elements on a page</figcaption></figure><ul><li>Headline with the entity name.</li><li>CTA (call-to-action) button for adding an object within the entity.</li><li>Search bar to quickly browse the records and navigate through (+filters if applicable).</li><li>Table with rows of object records.</li></ul><p>With the basics covered, it’s time to delve into the fundamental kit for CRUD operations, commonly referred to as the “happy path,” and examine its various scenarios from a UX perspective.</p><h3>Create</h3><p>The create operation allows users to add a new object to the database by displaying a CTA button labeled “Add [entity name]” as the entry point.</p><figure><img alt="The user flow diagram showcases steps for the ‘Create’ object operation." src="https://cdn-images-1.medium.com/max/1024/1*GXdvA5sO5RY8b5npLyWjBQ.png" /><figcaption>CREATE operation (Click &amp; Zoom to view)</figcaption></figure><h4>Scenario A — Object is added</h4><ol><li>The user clicks on the “Add [entity name]” button in the object’s entity list view page.</li><li>The configuration form shows up.</li><li>The user fills in all the required fields and clicks “Save”.</li><li>The system processes the adding request, and there are two possible outcomes:</li></ol><ul><li>The system creates the object successfully and redirects the user to the object’s entity list view. Displaying feedback that the object was successfully created through a notification/toast at the end of this scenario.</li><li>The system cannot create the object because an error occurred (due to a backend issue, unstable connection, etc.) and redirects the user to the object’s entity list view. Displaying feedback with the reason caused the problem through notification/toast at the end of this scenario.</li></ul><blockquote><em>Providing a clear and concise message explaining the exact reason for the error (e.g. “Error: No sufficient permissions”) can help the user understand what went wrong and potentially resolve the issue.</em></blockquote><h4>Scenario B — Leave page without saving changes</h4><ol><li>The user clicks on the “Add [entity name]” button in the object’s entity list view page.</li><li>The configuration form shows up.</li><li>The user fills in some data and leaves the page (clicks the “Back” browser button or “Cancel”, navigates to another page in the system, etc.).</li><li>A standard browser modal window “Unsaved changes” shows up:</li></ol><ul><li>If the user clicks “Leave”, the system redirects them back to the location they were aiming for.</li><li>If the user clicks “Cancel”, the modal window closes, and the user stays on the configuration page.</li></ul><p><em>Preventing users from accidentally leaving the page and losing their entered data is important for product development. While using a browser modal window for the “ Unsaved changes” scenario can be helpful, it’s not necessarily a universal rule. Designers should explore various options and select the best solution that meets user and business needs, is feasible, and fits into the current system architecture.</em></p><h3>Read</h3><p>The read operation typically allows users to retrieve specific records from the database based on a set of criteria. This can be done by entering a search query or applying filters to the data. Once the record is retrieved, users can view all the details of that particular object by clicking on the associated row in the table.</p><p><em>It’s important to note that the read operation can also include features such as pagination, sorting, and grouping, which allow users to organize and view large sets of data more efficiently.</em></p><figure><img alt="The user flow diagram showcases steps for the ‘Read’ object operation." src="https://cdn-images-1.medium.com/max/1024/1*uj_z4_zxM96JmLI98ZWFUg.png" /><figcaption>READ operation (Click &amp; Zoom to view)</figcaption></figure><h4>Scenario A — Search results found</h4><ol><li>The user enters a keyword in a search bar.</li><li>The system filters a table and displays the records matching to search query.</li><li>The user clicks on an object’s link in the table.</li><li>The configuration form shows up.</li></ol><h4>Scenario B — No matching search results</h4><ol><li>The user enters a keyword in a search bar.</li><li>The system can’t find any matching data and displays a message saying no matching results found.</li></ol><h3>Update</h3><p>The update operation is very similar to the create. It allows users to modify the details of an existing record in the database. To perform an update, the user would typically need to navigate to the object’s configuration form, which can usually be accessed by clicking on the associated row or a particular link-cell in the table.</p><p><em>Note that some systems may have different permissions or access levels that restrict users from making certain updates. The ability to modify records may be limited depending on the user’s role or permissions.</em></p><figure><img alt="The user flow diagram showcases steps for the ‘Update’ object operation." src="https://cdn-images-1.medium.com/max/1024/1*2QGmR5yOVT1UzbGL5IUjTg.png" /><figcaption>UPDATE operation (Click &amp; Zoom to view)</figcaption></figure><h4>Scenario A — Object is updated</h4><ol><li>The user clicks on an object’s row/link-cell in the table.</li><li>The configuration form shows up.</li><li>The user fills in all the required fields and clicks “Save”.</li><li>The system processes the updating request, and there are two possible outcomes:</li></ol><ul><li>The system updates the object successfully and redirects the user to the object’s entity list view. Displaying feedback that the object was successfully updated through a notification/toast at the end of this scenario.</li><li>The system cannot update the object because an error occurred (due to a backend issue, unstable connection, etc.) and redirects the user to the object’s entity list view. Displaying feedback with the reason caused the problem through notification/toast at the end of this scenario.</li></ul><h4>Scenario B — Leave page without saving changes</h4><ol><li>The user clicks on an object’s row/link-cell in the table.</li><li>The configuration form shows up.</li><li>The user adjusts some data and leaves the page (clicks the “Back” browser button or “Cancel”, navigates to another page in the system, etc.).</li><li>A standard browser modal window “Unsaved changes” shows up:</li></ol><ul><li>If the user clicks “Leave”, the system redirects them back to the location they were aiming for.</li><li>If the user clicks “Cancel”, the modal window closes, and the user stays on the configuration page.</li></ul><h3>Delete</h3><p>The delete operation allows users to delete records from a database that are no longer needed.</p><p>If users want to delete some objects, it could be given two options for the users:</p><ol><li>From the list view: single or bulk deletion through the action trigger (icon, link).</li><li>From the configuration form: single object deletion through the action trigger (icon, link).</li></ol><p>Let’s review all these scenarios together.</p><figure><img alt="The user flow diagram showcases steps for the ‘Delete’ object from the list view operation." src="https://cdn-images-1.medium.com/max/1024/1*f69a20Y7PIKrq1s-pmRmug.png" /><figcaption>DELETE operation from the list view (Click &amp; Zoom to view)</figcaption></figure><figure><img alt="The user flow diagram showcases steps for the ‘Delete’ object inside the configuration form operation." src="https://cdn-images-1.medium.com/max/1024/1*DK99Qql41_MAaWMJQOQwIw.png" /><figcaption>DELETE operation from the configuration form (Click &amp; Zoom to view)</figcaption></figure><h4>Scenario A — Deletion from the list view</h4><ol><li>The user clicks on the “Delete” action button in the table.</li><li>The system shows a confirmation dialog box to clarify the user’s intentions.</li><li>The user confirms by clicking the “Delete”.</li><li>The system processes the deletion request, and there are two possible outcomes:</li></ol><ul><li>The system deletes the object successfully. Displaying feedback that the object was successfully deleted through a notification/toast at the end of this scenario.</li><li>The system could not delete the object because an error occurred (due to a backend issue, unstable connection, etc.). Displaying feedback with the reason caused the problem through notification/toast at the end of this scenario.</li></ul><h4>Scenario B — Deletion from the configuration form</h4><ol><li>The user is on the configuration form and clicks on the “‘Delete” button.</li><li>The system shows a confirmation dialog box to clarify the user’s intentions.</li><li>The user confirms by clicking the “Delete”.</li><li>The system processes the deletion request, and there are two possible outcomes:</li></ol><ul><li>The system deletes the object successfully and redirects the user to the object’s entity list view. Displaying feedback that the object was successfully deleted through a notification/toast at the end of this scenario.</li><li>The system could not delete the object because an error occurred (due to a backend issue, unstable connection, etc.) and redirects the user to the object’s entity list view. Displaying feedback with the reason caused the problem through notification/toast at the end of this scenario.</li></ul><p><em>As product designers, it’s important to prevent users from losing their entered data accidentally by leaving a page. However, we should focus and care more about the deletion operation. Note that some objects might be more vital than others in the system, such as the core or those with strong dependencies on other objects (for example, User Roles). By providing your end users with additional information on the implications and effects of deleting such objects, they can make informed decisions before proceeding with the deletion.</em></p><p><em>Moreover, adding an ‘Undo’ action to the deletion workflow can be a valuable feature to consider. This feature can help users restore deleted objects, minimizing the risk of accidental deletions and offering a safety net in case of mistakes. With these considerations in mind, we can design deletion workflows that balance user needs and system requirements, making the user experience more transparent, efficient, and satisfying.</em></p><h3>Bonus tips</h3><blockquote>❗ Keep in mind that these are only guidelines and not a one-size-fits-all solution for every system. Nonetheless, carefully considering these scenarios can go a long way in preventing issues, bugs and improving the user experience.</blockquote><blockquote>❗ Do not forget to establish UX copyright standards to maintain consistency throughout the system. For example, when it comes to creating new objects, you can choose to use a button label such as “Add,” “Create,” or “Add [entity name].” It’s crucial to verify that this label is consistent across the entire system and is documented in the knowledge base to ensure that all team members are aware of the pattern.</blockquote><blockquote>❗ While this article won’t cover validation behavior, it’s essential to consider a way to validate all the required data, formats, and duplicates in your text fields. There are various ways to accomplish this, including regular expressions, data type checks, and other validation techniques.</blockquote><blockquote>❗ ️Also important to consider how the application should behave in various scenarios, such as empty list view pages, lacking user permissions, or other edge cases that might be applicable to your system. These scenarios should be assessed during the design process to ensure a smooth and intuitive user experience.</blockquote><h3>Thank You for reading!</h3><p>If you found this article helpful and informative, please <strong>👏</strong> so others can also discover it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2630affbc1e5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/mastering-crud-operations-a-framework-for-seamless-product-design-2630affbc1e5">Mastering CRUD Operations: a Framework for Seamless Product Design</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>