<?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 Ovidiu Boc on Medium]]></title>
        <description><![CDATA[Stories by Ovidiu Boc on Medium]]></description>
        <link>https://medium.com/@ovidiuboc?source=rss-ec15075bb197------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Daao4A1xePbp6IUhxoYS9Q.jpeg</url>
            <title>Stories by Ovidiu Boc on Medium</title>
            <link>https://medium.com/@ovidiuboc?source=rss-ec15075bb197------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 22:00:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ovidiuboc/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[How to land a (freelance) job in Enterprise UX]]></title>
            <link>https://medium.com/design-bootcamp/how-to-land-a-freelance-job-in-enterprise-ux-9410ec93879b?source=rss-ec15075bb197------2</link>
            <guid isPermaLink="false">https://medium.com/p/9410ec93879b</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[enterprise-ux]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[freelancing]]></category>
            <dc:creator><![CDATA[Ovidiu Boc]]></dc:creator>
            <pubDate>Mon, 18 Nov 2024 10:59:48 GMT</pubDate>
            <atom:updated>2024-11-20T12:09:02.018Z</atom:updated>
            <content:encoded><![CDATA[<h4>A few tips to get you started if you find the EUX space interesting.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UvCgjQ2xE0o_PPu5JswwPQ.png" /><figcaption>One of the messages I’ve received lately on LinkedIn</figcaption></figure><p>In the past few weeks I’ve received at least 3 messages similar to the one in the screenshot above. So I’ve started connecting the dots and coupled this with the <em>Enterprise Design Thinking</em>¹ framework released by IBM a few years back, the increased appetite for specialized write-ups and reports on Enterprise Design — take a look at the <em>UXPin e-Books</em>² collection for example — and the rise of EUX related conferences and events in recent years.</p><p>There’s definitely something exciting happening in the enterprise space and I believe most of it has to do with a new level of design maturity.</p><p>Considering the resistance to change and the internal politics you have to deal with in the corporate world, going freelance and trying to design enterprise solutions from the outside starts to makes sense. These people might be onto something 🤔</p><p>Therefore, I’ve decided to go through my LinkedIn messages and publish a few tips I’ve sent along in my replies, hoping you’ll find at least some of them useful — the rest will probably seem obvious, but I’ll keep them in anyway, maybe they’ll help someone.</p><p>Although it’s definitely doable, landing an enterprise project as a freelance designer might be a bit harder than landing a B2C project. Your reliability, the quality of your work and your ability to provide an integrated service will play an important role.</p><p>When they outsource their design jobs, the corporate world wants to make sure you are suitable for the job, which means you have to check the right boxes. And they love coming up with new ones (it’s like the bat signal, it makes them “visible” across the org and it shows they are “busy”).</p><p>But let’s take them one by one.</p><h4>Your reliability</h4><p>Usually, an enterprise project is not your typical one-off job, it has multiple dependencies and development paths — finishing just one of them and then dropping off is not something they are looking for. They need continuity, they need documented solutions and assistance during the implementation and they need you to deliver on the agreed deadlines and commitments.</p><p>They need full transparency and constant reassurance that you’re going to make them look good “upstairs”, help them achieve their goals and reach their targets — this is what’s “in” for them, these are the stakes of contracting you. Build trust by translating your added value into their terms and objectives. Don’t make it about you, make it about them.</p><p>They need someone for the long haul and they need to feel covered if you drop out from the project at any point in time for whatever reason.</p><p>You’re the “hot potato”, find ways to prove you’re reliable and accountable.</p><h4>The quality of your work</h4><p>Ideally, they want someone with a proven track record. It’s not a deal breaker, but your portfolio should either highlight other projects you’ve done in this space OR showcase how you’d tackle one. Keep in mind, an EUX portfolio is not the same as your typical B2C portfolio — the approach and the main focus should be slightly different. More on this topic in a future article, if there’s enough interest around it.</p><p>They need someone who knows the difference between designing for a consumer and designing for an employee, an organization or another business. They need somebody flexible, who understands that parts of the process might have some red tape wrapped around them, whilst others might take longer than expected and some might involve quite a bit of bureaucracy.</p><p>They also want to make sure you’re taking inclusiveness and accessibility seriously and that “systems thinking” is not just a buzzword in your nicely crafted slide deck. They really need scalable solutions that fit a larger ecosystem and a larger audience. Sometimes, not being able to check these boxes results in liability issues for them.</p><p>If you’re interested in learning more, check out these articles I wrote a while ago, they might give you some valuable pointers:</p><ul><li><a href="https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-1-b70c0578accd">Designing a data-heavy enterprise application — Part 1</a></li><li><a href="https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-2-9af9f172f0e6">Designing a data-heavy enterprise application — Part 2</a></li></ul><p>Lastly, be prepared to face “the legacy” or “the deep end” and have a clear strategy to get around it — these are ancient parts of older platforms that cannot be touched simply because nobody knows how to change them or what the implications are if they do so. It’s a special kind of surprise party that nobody tells you about until you’re weeks deep in your work. Be prepared and inquire about it in advance.</p><h4>Integrated services</h4><p>More often than not, they are looking for a jack-of-all-trades or a team capable of delivering (almost) everything related to a particular project. As a freelance designer, your collaboration might start off with the design part, but there’s a high chance it will evolve into other areas.</p><p>Think ahead about partnering up with various people, having a different skill set than yours to complement your work and allow you to provide a broader set of integrated services.</p><p>If you don’t master the visuals so well, pair up with a visual designer to cover that part. Not confident enough in tackling large data visualizations? Look for designers with these skills. Same goes for front-end engineers, copywriters, SEO experts, and so on.</p><p>If things get serious, think about putting together a small team. Who knows where the journey might take you 🙃</p><p>Considering the above, my advice would be to work on a few things in parallel:</p><h4>Grow your Enterprise UX network</h4><p>Reach out to design hiring managers in companies you’re interested in, connect with recruiters in the enterprise space and make yourself known. Join design communities and start making connections.</p><p>Last but not least, one of the most efficient ways to grow your network is to attend design events in general, and EUX focused conferences in particular — there aren’t too many of these yet, but they are growing.</p><p>For example, the most recent one I can recommend is the <em>Enterprise UX Conference</em>³ that took place in Amsterdam, NL earlier this month (November 2024). They’ve started the 1st edition in 2023 and it’s definitely worth going. If only they could decide on holding the entire event in English… 🤗</p><p>If you know other EUX events worth going to, I’d love to hear about them.</p><h4>Grow your audience</h4><p>Write on Enterprise UX related topics (I’d advise either Medium or LinkedIn) or start mentoring and coaching other designers on platforms like ADPList.org or Memorisely.com and get recommended or invited to hold in-person workshops (get your foot in the door).</p><p>You could also do the most obvious thing out there and publish your EUX work in various places (Read.cv, Dribble, you name it) but I’m highly doubting it’s going to be possible for a number of reasons (NDAs, complexity and domain knowledge barriers, etc).</p><p>Cheers and good luck out there!</p><h4>References</h4><ol><li><a href="https://www.ibm.com/design/thinking/page/framework">Enterprise Design Thinking Framework by IBM</a></li><li><a href="https://www.uxpin.com/studio/ebooks/">UXPin e-Books Collection</a></li><li><a href="https://enterpriseux.nl/">Enterprise UX Conference in Amsterdam</a></li></ol><p><em>If you found this article helpful, </em><strong><em>please consider giving it a few claps </em></strong><em>👏 . You can also ping me on </em><a href="https://linkedin.com/in/ovidiuboc/"><em>LinkedIn</em></a><em> if you have any questions, I’d be glad to help.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9410ec93879b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/how-to-land-a-freelance-job-in-enterprise-ux-9410ec93879b">How to land a (freelance) job in Enterprise UX</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[Designing a data-heavy enterprise application — Part 2]]></title>
            <link>https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-2-9af9f172f0e6?source=rss-ec15075bb197------2</link>
            <guid isPermaLink="false">https://medium.com/p/9af9f172f0e6</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[enterprise-ux]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Ovidiu Boc]]></dc:creator>
            <pubDate>Thu, 04 Jan 2024 04:12:44 GMT</pubDate>
            <atom:updated>2024-01-31T08:08:23.561Z</atom:updated>
            <content:encoded><![CDATA[<h3>Designing a data-heavy enterprise application — Part 2</h3><h4>A practical guide on designing for speed and repetitive use, accessibility and scalability in enterprise applications.</h4><figure><img alt="An excerpt of requirements for enterprise readiness: security, scalability, SSO, RBAC, compliance, cost control, efficiency, accessibility" src="https://cdn-images-1.medium.com/max/1024/1*kQacOrYm6bvo72hqYb9Hdg.png" /><figcaption>Excerpt of requirements for enterprise readiness</figcaption></figure><p>First, let’s do a brief recap of the main topics covered in the 1st part:</p><ul><li><strong>Brief comparison</strong> on designing for enterprise vs consumer products.</li><li><strong>Loading data</strong>: downsize on purpose, divide and conquer, manage the expectations, don’t interrupt.</li><li><strong>Error handling.</strong></li><li><strong>Display data</strong>: no data, too little data, too much data, protected data, format data.</li></ul><p>If you’ve missed the 1st part, please read it and show your support here: <br><a href="https://bootcamp.uxdesign.cc/designing-a-data-heavy-enterprise-application-part-1-b70c0578accd">Designing a data-heavy enterprise application — Part 1</a></p><h4>4 more to go</h4><p>In this 2nd and final part, we’re going to focus on yet another set of 4 practical guidelines we need to consider when designing a data-heavy enterprise application.</p><p>If you are a product designer who is already working on an enterprise application 👋 or you’re thinking about joining an enterprise team, you might find the pointers in this guide useful to take into account.</p><h3><strong>Take accessibility seriously</strong></h3><h4>Low vision</h4><p>I know you probably love using those subtle shades of graphite or that thin Inter style and I have to agree: they look amazing on a retina display. Sadly though, they won’t be visible on the vast majority of beamers (or even some smart TVs) you’ll find in most enterprises. Furthermore, they will definitely NOT be appreciated by the employees with poor or deficitary eyesight. <strong>Be considerate, use a decent contrast ratio and stroke width</strong>. Testing your designs using a different light and device setup will also help — e.g. try it on an old(er) laptop / monitor with low PPI density or see how it looks like on a beamer with the lights on.</p><h4>Color blindness</h4><p>Don’t forget about the color blind employees either — they will probably be amongst your users (latest statistics mention around 300 million people suffering from color blindness worldwide¹). To make your designs accessible to them, don’t rely solely on color-coding when displaying key data. For example, showing the health state of an item, the variation of a KPI or the status of a system using colors alone is not enough — <strong>back up the color indicator by using a label (text or numbers), an icon or a pattern</strong>. If you can’t use either of these, at least make sure you provide a short tooltip indicating what the color means — you should do this anyway, it helps ease the learning curve.</p><p>You’re still thinking about the “pattern”, aren’t you? 😛 I know it’s not a common or a popular choice, but it might be helpful in some cases — that’s why I’m going to focus on it for a bit. Let’s consider a health timeline that uses the classic RAG (Red, Amber, Green) convention to show the evolution of a system’s health state over time:</p><ul><li><strong>The Green</strong> usually means “healthy”, “no action required”, “the system is running as expected” and it’s the least <em>interesting </em>of all 3 colors. Basically, nobody’s really interested in the Green. And that’s because, under normal circumstances, everything is supposed to be Green. So… let’s make this as “dull” as possible and NOT use any pattern for it so it doesn’t stand out.</li><li><strong>The Amber</strong> usually means “warning”, “you should pay attention”, “the system is deviating from its normal parameters”. Now this is something the user might be interested in, thus we need to make it distinguishable from the Green. Using some simple diagonal lines as a pattern should be enough.</li><li><strong>The Red</strong> usually means “error”, “you must take action now”, “the system is malfunctioning or is in critical condition”. The user will definitely be interested in this and it’s clearly more important than the Amber. Let’s aim for consistency and build on Amber’s pattern by alternating the diagonal lines as a pattern for Red.</li></ul><figure><img alt="4 examples of health timelines using red, amber and green segments, with and without patterns" src="https://cdn-images-1.medium.com/max/1024/1*wSc1PDMVergbYNPwTKW7Ww.png" /><figcaption>Top-down: unsafe for low vision and color blindness, safe for low vision but not for color blindness, optimal solution, simulation w/o using colors</figcaption></figure><p>I’ve used the diagonal lines as an example, but you can get really creative with these patterns — just keep in mind a couple of rules:</p><ul><li><strong>try to keep them consistent and don’t over do it</strong>, otherwise the whole interface can become really noisy, really fast;</li><li><strong>tone them down</strong>, they should be subtle enough to be noticeable by color blind users, but not getting in the way or becoming a distraction for the rest of the users.</li></ul><p>The advantage of using patterns over labels and icons is that they work nicely as a container fill (e.g. status / progress bars, gauge / bar / circular charts, etc) without taking up additional space. If used correctly, they can be quite effective.</p><p><strong>Bottom line</strong>:</p><ul><li><strong>Low vision and color blindness are some of the most frequent accessibility issues</strong> you should be aware of and design for, but it doesn’t mean they are the only ones.</li><li><strong>You don’t have to aim for the highest WCAG compliance level</strong>² (AA will do just fine in most cases), but not taking accessibility seriously means losing money when it comes to enterprise products and, sometimes, it might have liability implications as well.</li></ul><h3><strong>Design for speed and repetitive use</strong></h3><h4>Optimize page scanning</h4><p>Improving the time spent by an employee to scan a page results in more tasks completed by that employee in a shorter period of time, which leads to a higher efficiency score. Let’s see how we can achieve this:</p><ul><li><strong>Mind the typography</strong>: a clear, well calibrated typeface, with good letter-spacing (even at small sizes), optimal body size (not too wide, not too narrow) and greater x-height will work out just fine for a data-heavy enterprise application in most cases. Due to the high volume of data, you will need to optimize the space usage whilst keeping an eye on the readability and legibility of the content. For example, a looser letter-spacing or a wider body size will increase the real estate needed to display the content, whereas a tighter letter-spacing or a lower x-height will make the text harder to read at small sizes. Last but not least, use tabular figures (monospaced numbers), rather than proportional digits, in tables or places where values may change often — they are easier to scan and compare with each other.</li><li><strong>Let the data stand out</strong> and minimize the noise by removing, replacing or toning down repetitive labels and secondary content (e.g. helpers, subtitles, descriptions, etc.) to make the interface faster to scan.</li><li><strong>Use visual anchors and proper hierarchy</strong> to drive the attention to certain areas and restrain yourself from emphasizing too many elements — soon enough you’ll be finding yourself in a tough spot where almost everything will be emphasized, thus nothing will stand out.</li><li><strong>Respect the UI conventions</strong> used in the market your application is a part of to speed up recognition and improve scanning time — pay close attention to icons and symbols or other specific UI elements. Take it a a corollary of Jakob’s law³ if you wish.</li><li><strong>Make consecutive items distinguishable</strong> so they are easier to scan: use alternating background colors on even vs odd rows in tables, separate (block) list items properly (e.g. more white space, dividers, etc), show the Y axis guides on graphs, and so on.</li><li><strong>Group similar items together</strong> based on easily recognizable criteria to reduce the cognitive load and increase the scanning speed: group form fields into sections with suggestive labels, group settings based on application scope, group options based on impact or functionality, group menu items based on user interest, etc. Play with Gestalt’s principles⁴, especially the “common region”, “proximity” and “similarity” to achieve the desired result — try not to use too many borders and dividers, they tend to add a lot of noise.</li></ul><h4>Include keyboard shortcuts</h4><p>To facilitate repetitive use and increase the task completion speed, consider adding keyboard shortcuts for the most frequent actions an employee has to execute. If you decide to support them, make sure they are easily discoverable — mention the keyboard shortcuts individually in context (tooltips, menu items, button labels, etc.) and reserve a dedicated place for them in the UI (e.g. in the help center, global settings, etc).</p><figure><img alt="A panel showcasing the keyboard shortcuts used in Figma" src="https://cdn-images-1.medium.com/max/1024/1*wIAjaS5g-llAijSyKJIcQA.png" /><figcaption>The shortcuts panel in Figma</figcaption></figure><p>Regardless of the decision to add keyboard shortcuts or not, you should <strong>always check the basics as part of your QA process</strong>. Make sure:</p><ul><li>Using the “<strong>tab</strong>” key to switch between form fields or actionable elements is done in the correct order — important for data entry tasks;</li><li>Hitting the “<strong>return</strong>” key submits forms and executes (focused) actions;</li><li>Pressing the “<strong>esc</strong>” key closes recently opened popups (e.g. drawers, modals, popovers, etc);</li><li>Using the <strong>up / down arrows</strong> goes over the options in a (dropdown) list;</li></ul><p>Sometimes, it also helps to <strong>auto-focus inputs or primary buttons</strong> to make them easier to fill in or hit using the keyboard (otherwise, the user has to switch from the keyboard to do an extra click — it costs time).</p><h4>Foster continuity</h4><p>Speed of use also depends on continuity — avoid dead ends at all costs, they cause significant delays that add up to a slow employee performance (and frustration). Each interface should have a clear purpose (a primary action) and/or it should provide alternative routes the user can follow to move backward, forward or sideways (jump to another flow).</p><p>For example, try to include follow-up actions in the confirmation messages to either repeat the operation (e.g. add another), undo it (e.g. continue editing) or jump to a new entry point (e.g. submit for approval).</p><figure><img alt="The confirmations message shown in Gmail after you’ve successfully sent a message, featuring an “undo” and “view message” follow-up actions" src="https://cdn-images-1.medium.com/max/1024/1*70k6NoLA4LDK60TIbyxceA.png" /><figcaption>Confirmation message in Gmail</figcaption></figure><p>The 1st part of this practical guide on designing a data-heavy enterprise application⁵ includes additional tactics you can consider to create a fluid experience and increase the speed of use in different scenarios.</p><h4>Set proper defaults</h4><p>Unlike users of mainstream consumer products, employees are less likely to change the defaults provided by your enterprise application either because they are not sufficiently motivated, they are not aware they can actually change them or they don’t know how to do it. Lastly, there are also cases when certain employees are not allowed to change the defaults (insufficient rights).</p><p>Setting proper defaults (and remembering them if the user has changed them) can therefore save time and improve speed, especially for repetitive tasks.</p><p>When doing so, remember each user profile has different needs — personalize the defaults for each of them. For example, setting the default viewing to “list mode” might be a suitable choice for analysts, whereas “heat map” or “tree map” might be a better default choice for executives.</p><p>If possible, help the user by tracking his/her choices and set or change the defaults to match the most frequent ones (e.g. most searched keywords, most chosen export options, most used sorting criteria, etc).</p><h4>Improve findability</h4><p>This is a short but often overlooked one: ensure users can <strong>easily</strong> find what they are looking for. It saves time and speeds up usage:</p><ul><li>Always sort items in a list or a table by using a clear, easy to recognize, relevant criteria (by name, time, size, type, etc) and try to avoid relying on abstract, hard to “visualize” or hard to understand sorting rules by default — if you must use one, offer an explanation (as a tooltip or otherwise) that includes both the “how” (how it works) and the “why” (why it’s used there).</li><li>Make sure the global / local search actually works as intended. It might be more expensive or even impossible to implement in some cases (due to the data storage architecture), but always aim to use a full text search over a prefix search as it feels more natural and it matches the user’s mental model better.</li><li>Meet the user half way when he/she is searching for something and give suggestions whenever possible — it increases the task completion rate.</li><li>Using a filtering system that allows the user to slice and dice the data presented to him/her should be a given. However, if you want to speed up this process, you should consider supporting contextual filtering (or “ad-hoc filters”) as well throughout the application. In other words, besides a dedicated place in the UI that showcases the available filters, attach an additional action to filterable items whenever they are listed in the UI (e.g. “add to filters”, “filter by value”, “exclude this value”, etc). This way, the user doesn’t have to spend time on selecting the value he’s trying to filter on, copy it, scroll / find the filters panel, paste it and scroll back to where he was initially — it saves time. Take a look at the example below:</li></ul><figure><img alt="An excerpt from a Grafana dashboard showcasing the use of ad-hoc filters" src="https://cdn-images-1.medium.com/max/1024/1*uXdkJQw-3C8kuQ5v-6yu2A.png" /><figcaption>Ad-hoc filters in Grafana</figcaption></figure><h4>Follow the function</h4><p>“Form follows function” couldn’t be more appropriate for enterprise applications — keep this in mind when you think about adding shadows, glows, gradients, animations and other effects. Ask yourself a few questions before deciding to add them:</p><ul><li>Do they have a clear purpose? Do they serve a function?</li><li>Are they scalable enough to be applied on other similar elements throughout the interface to keep consistency?</li><li>Do they increase the waiting time for the user? Does the user have to wait longer for a page to load, an animation to finish, etc. before he/she can move on?</li><li>Are they making the page harder to scan? Are the shadows, glows and other effects distracting the user’s attention from the content?</li></ul><p>It’s not a black or white decisive process and it definitely does not mean you shouldn’t use any effects at all. It just means you should be able to justify their usage by explaining their added value.</p><p>For example, it’s perfectly ok and even advisable to use a slide-in / slide-out animation to show / hide a side drawer or to use a smooth scrolling effect to jump to a particular section in the page when clicking an anchor — they help the user better understand how the system reacted (B) to their action (A) by showing the transition of the UI between the two moments in time (A → B). It’s also perfectly ok to use shadows on elevated elements (e.g. anything in the “popups” category) or elements you want to stand out. And the list goes on.</p><p>But you should try to avoid glowing or fading effects on links and buttons, or animating everything that can be animated — just because you can, doesn’t mean you should. Especially with repetitive use, they can become rather annoying and delay the user’s task completion. Similar goes for shadows for example — if you use them on every container, they are going to add a lot of (unnecessary) noise and decrease the page scanning time.</p><h4>Don’t over-simplify</h4><p>Less is not always more, or at least not when it comes to enterprise applications and speed of use. <a href="https://medium.com/u/ab0fa74d2f6">Morgane Peng</a> wrote a nice article on over-simplification⁶ that I highly recommend as it showcases different scenarios in which displaying information in space is more efficient than displaying information in time.</p><p>Contrary to Hick’s law⁷ (<em>the time it takes to make a decision increases with the number and complexity of choices</em>), there are cases when an enterprise employee needs all the relevant information at hand on a single screen to be able to do his job. For example, a broker or a financial analyst helping a customer over the phone has similar needs to a sound engineer in a recording studio or an airplane pilot in mid air — they all need their information spread out (in space) because time is of essence and their repetitive work routine, like a memory muscle, plays an important role into helping them making quick decisions.</p><p>In such cases, displaying information in time (e.g. using a multi step flow, progressive disclosure, etc.) would simply create a lot of friction and delays, and can even lead to unfortunate outcomes.</p><h3><strong>Plan for scalability</strong></h3><p>Ideally, you’d know beforehand the type of data your product is going to ingest and/or manage and you’d be able to start planning around it: navigation schema, red routes, layout structure, interaction patterns, taxonomy, etc. This is the ideal scenario 🤞 but, as it often happens with enterprise applications, it doesn’t always play out this way.</p><p>Instead, you’ll probably get your hands on a very basic data model (the foundation) to start width and, unlike most consumer products, chances are that this data model will continue to evolve over time. The challenge is to plan for a degree of scalability that will sustain this evolution for as long as possible.</p><p>In other words, <strong>try to anticipate and design a solution that doesn’t need a full redesign from scratch each time the data model evolves</strong>. You will eventually need a complete remake at some point, that’s inevitable simply because the entire structure will need a fundamental change in order to accommodate new requirements — take a look at Slack’s overhaul from August 2023 for example and the reasons behind their decision⁸.</p><p>You can think about this evolution as an array (1 dimension) that grows into a matrix (2 dimensions), a cube (3 dimensions) or… even a hypercube (4+ dimensions). In practice, a (very basic) evolution might look like this:</p><ul><li><strong>Products</strong> = The 1st dimension. It contains the core data of your enterprise application. You’ll most probably start here, with just an array consisting of the most basic information for each product. For the sake of simplicity, let’s say the most important data point is the all-time sales figure.</li><li><strong>Regions</strong> = The 2nd dimension. It aims to give more accurate insights using a geographical segmentation. You now have a matrix, similar to an Excel sheet, showcasing the all-time sales figure for each product line, per geographical region. Previously, your data point required a single coordinate to identify it (the product), now it requires 2 coordinates (the product and the region).</li><li><strong>Time</strong> = The 3rd dimension. Instead of having a single data point for all-time sales that uses 2 coordinates (the product and the region), we add a new one into the mix: distribution over time. Now you have a cube you can slice and dice as needed to get the data you’re looking for — the concept so far looks similar to an OLAP cube⁹ (see below).</li></ul><figure><img alt="An OLAP cube featuring “Products”, “Geography” and “Time” as dimensions" src="https://cdn-images-1.medium.com/max/1024/1*vOs8lr13TEmyTNw3Nq3v6w.png" /><figcaption>Credit: Cedric Chin / holistics.io</figcaption></figure><p>Let’s revert this back to your starting point: you only have the “products” dimension and, depending on their number, you might be tempted to use this as your primary navigation — why not, right? The users will have a quick and direct access to the products they are interested in. The layout you might be tempted to use will also reflect the simplicity of a single dimension. And so on.</p><p>Once we get to the 2nd point and add the “regions” into the mix, you realize the layout might need a few changes to reflect a product segmentation by regions. At this stage you might also decide to add some basic filtering and ordering criteria to enhance speed of use and findability. It is also at this stage that you have to ask yourself if a region might evolve into something that’s going to contain more than just product information. And, if that’s the case, shouldn’t they be considered a 1st class citizen in your navigation schema as well? This means you should probably reconsider the navigation structure you were planning for at the previous point. It also means you’ve created a pivot change in your information architecture — this is something that’s definitely going to happen quite often, plan for it accordingly.</p><p>Adding the “time” as the 3rd dimension raises a whole new set of challenges. It’s definitely going to be a widely used filtering criteria for many of your product sections, so you have to ask yourself if it makes sense to consider this a global, persistent filter across the whole application or a local, temporary one for each product section. Furthermore, chances are your enterprise application has to integrate with other applications within a larger ecosystem that will, most likely, have a time dimension as well — make sure you aim for consistency between your app and the rest of that ecosystem, you don’t want to end up with a different approach for the same concept, it will confuse the users and put a dent in your application’s usability score.</p><p>Care to make it more interesting? 😅 Envision adding more dimensions (e.g. business units, stock management, distribution lines, etc.) and try to anticipate the challenges you’ll be facing at each step. I’m going to leave it at this, but when it comes to scalability for enterprise, you should take into account the following:</p><ul><li><strong>Try to anticipate the evolution of the data model </strong>— look at your competitors, study where the market is heading, get some deep insights and forecasts from 3rd party advisors (e.g. Gartner, Forrester, etc).</li><li><strong>Leave room for new dimensions to be added</strong> and always consider pivoting your information architecture for better discoverability (of the newly added dimensions) and greater flexibility (allowing the user to choose his/her own starting point). Looking at the previous example I was using to illustrate the evolution of the data model, you need to consider both the users that will examine a “product” across multiple “regions” AND the users that will focus on a “region” to examine multiple “products” — offer both entry points.</li><li><strong>Opt for a versatile layout designed for growth</strong>, don’t make decisions based on the current requirements alone. For example, don’t go for a horizontal filtering system because you have a limited set of criteria right now — chances are you’ll have to fit more options when new dimensions will be added → opt for a vertical orientation or a progressive filtering approach; don’t use a toggle / radio button component as the main control for content segmentation in a product section — you’re probably going to need to display more criteria with longer labels when the data model evolves → use a tabbing system instead; don’t use a specific sidebar that serves a narrow purpose — soon enough you’ll have to repurpose it to fit new functionality → aim for a generic, multi purpose sidebar from the start if possible; and so on…</li><li><strong>Use interaction patterns, technical language and other conventions that align with the market</strong> your application is a part of to minimize the knowledge gap between the mental model (what the user expects) and the conceptual model (what you design), and ensure better consistency with other systems (conceptual models alignment).</li></ul><h3><strong>Match the learning curve</strong></h3><p>Analyze the existing (or potential) learning curve and give progressive reduction¹⁰ a chance if applicable. It is a tremendous and somewhat risky task to consider but, in the right context, it might yield some interesting results. Therefore, if you have to design a complex enterprise product, with an overwhelming UI, maybe it’s worth investigating this concept.</p><blockquote>Progressive reduction makes the users’ life easier by simplifying the interface as they become more and more familiar with it. In other words, you reward the users with a much lighter, streamlined interface, tailored to their knowledge and experience over time.</blockquote><p>A classic example is the button that starts off with an icon and a label — after the user has made the association between the icon and the label, we drop the label and repeat the process to keep only the icon as an interactive equivalent control to the initial button.</p><p>It might also be interesting to use (with caution) if the enterprise app you’re designing is prone to frequent and repetitive use (e.g. on a daily basis, going over the same tasks and executing the same actions).</p><p>On the flip side, it might be challenging and costly to implement and / or maintain, and it might backfire if there is too much resistance to change. Choose wisely 😇.</p><h4>References</h4><ol><li><a href="https://www.colourblindawareness.org/colour-blindness/">Color blindness</a></li><li><a href="https://www.w3.org/WAI/standards-guidelines/wcag/">Web Content Accessibility Guidelines (WCAG)</a></li><li><a href="https://lawsofux.com/jakobs-law/">Jakob’s law</a></li><li><a href="https://www.interaction-design.org/literature/topics/gestalt-principles">The Gestalt principles</a></li><li><a href="https://bootcamp.uxdesign.cc/designing-a-data-heavy-enterprise-application-part-1-b70c0578accd">Designing a data-heavy enterprise application — Part 1</a></li><li><a href="https://uxdesign.cc/over-complicated-over-simplified-the-ux-efficient-frontier-561d7773bc6b">Over-complicated? Over-simplified? The UX efficient frontier</a></li><li><a href="https://lawsofux.com/hicks-law/">Hick’s law</a></li><li><a href="https://slack.design/articles/how-our-biggest-redesign-yet-came-to-be/">The new Slack: How our biggest redesign yet came to be</a></li><li><a href="https://www.holistics.io/blog/the-rise-and-fall-of-the-olap-cube/">The rise and fall of the OLAP cube</a></li><li><a href="https://layervault.tumblr.com/post/42361566927/progressive-reduction">Progressive reduction</a></li></ol><p><em>If you found this article helpful, </em><strong><em>please consider giving it a few claps </em></strong><em>👏 . You can also ping me on </em><a href="https://linkedin.com/in/ovidiuboc/"><em>LinkedIn</em></a><em> if you have any questions, I’d be glad to help.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9af9f172f0e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-2-9af9f172f0e6">Designing a data-heavy enterprise application — Part 2</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[Designing a data-heavy enterprise application — Part 1]]></title>
            <link>https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-1-b70c0578accd?source=rss-ec15075bb197------2</link>
            <guid isPermaLink="false">https://medium.com/p/b70c0578accd</guid>
            <category><![CDATA[enterprise-ux]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Ovidiu Boc]]></dc:creator>
            <pubDate>Fri, 15 Dec 2023 08:44:00 GMT</pubDate>
            <atom:updated>2024-01-31T08:07:35.507Z</atom:updated>
            <content:encoded><![CDATA[<h4>A brief comparison and a practical guide on loading and displaying data or handling errors in enterprise vs consumer applications.</h4><figure><img alt="An excerpt of requirements for enterprise readiness: security, scalability, SSO, RBAC, compliance, cost control, efficiency, accessibility" src="https://cdn-images-1.medium.com/max/1024/1*2qs95jFu23piIW3pz6vojA.png" /><figcaption>Excerpt of requirements for enterprise readiness</figcaption></figure><p>Having spent quite a few years designing and reviewing data-heavy enterprise applications, I realised there are some specific guidelines we need to consider when designing enterprise products compared to mainstream consumer products.</p><p>And <strong>I don’t mean technical design guidelines</strong>, although there is a small overlap that might be interesting for technical people.</p><p>But, if you are a product designer who is already working on an enterprise application 👋 or you’re thinking about joining an enterprise team, you might find the pointers in this guide useful to take into account.</p><h3>Understanding the context</h3><p>So… what exactly is an enterprise application, what makes it so special to design for and why is the amount of information so important?</p><p>Well, for starters, Wikipedia defines an enterprise application as being <em>a computer software used to satisfy the needs of an organization rather than those of individual users</em>. It might be obvious, but this is actually one of the key differences between enterprise and consumer applications as <strong>the needs of an organization can easily span across multiple verticals that have little in common with the needs of individual users</strong> (e.g. security, compliance, cost control, scalability — across multiple divisions, integrations — with their existing services, and the list goes on).</p><figure><img alt="Enterprise apps you might have used or heard of: hubspot, mixpanel, salesforce, zendesk, stripe, intuit, jira, aws" src="https://cdn-images-1.medium.com/max/1024/1*s4X7xNN5HEG8a8fH1pDIEA.png" /><figcaption>Enterprise apps you might have used or heard of</figcaption></figure><p>Another key difference is the amount of information they are designed to work with. <strong>As a rule of thumb, most enterprise products ingest and / or manage incredible volumes of data:</strong></p><blockquote>Think of a HRMS processing millions of job applications per year (i.e. McDonald’s receives around 20 million job applications and makes around 2 million hires per year world wide) or an ITMS analyzing billions of events each month (i.e. Microsoft processes on average 600 billion security events on a monthly basis) and so on.</blockquote><p>This alone increases the level of complexity we need to design for as we need to <strong>take into account the performance of the entire ecosystem</strong> the application is part of.</p><p>Let’s highlight a few more (relevant) differences between enterprise and B2C products before we jump into the “solution” space — don’t worry, we’re not deep diving into this topic right now 😅, but we do have to understand the “specifics” of these applications. I’ve attached some useful resources at the end if you’re interested in more details.</p><h4>Consumer products</h4><ul><li>Most consumer products are solving a particular problem for one user group and they are mainly focused on retention, engagement, loyalty and conversion.</li><li>A typical user journey for a mainstream consumer product consists of a few linear steps, with limited entry points, and a few optional side quests (e.g. set up your account details on your way to the checkout).</li><li>Last but not least, a consumer product is, in most cases, used in a (very) personal context — e.g. using your own smartphone to look for an Uber, on your way to meet your friends, making your own decisions about the cost you are willing to pay for the ride (come on, take that Uber Black, you deserve it 😬). You want to use that application right there and then, but it’s also in your power to put it aside or replace it with something else at anytime.</li></ul><h4>Enterprise products</h4><ul><li>Enterprise products on the other hand are “one-size-fits-all” solutions for various user roles, with different permissions, responsibilities and levels of expertise. They primarily focus on efficiency, fault tolerance and repetitive use — in other words, their purpose is to help employees get their (repetitive) tasks done as fast, cheap and error free as possible.</li><li>A single user journey can easily include over 100 screens, spread across 2–3 tools or more, with non-linear tasks and various entry points.</li><li>Often times, the environment in which an enterprise product is used in can be highly regulated (think of banks and governmental institutions for example), stressful and impersonal, ranging from outdated hardware used by an employee in a crowded open space, to uncalibrated beamers with poor contrast or a matrix of high quality displays covering an entire wall in a decision making room.</li></ul><p>Let’s end this comparison with one last key difference: unlike B2C users, enterprise users don’t have the luxury of choosing whether or not they want to use a particular product — they have to use the one the company agreed on using and finish up the tasks assigned to them within their deadlines.</p><p><em>Now that we’ve built some empathy for the enterprise users, let’s dive into it and see how we can make their life easier. Or at least try</em> 😃</p><h3>Loading data</h3><p>Considering the large volumes of data being ingested, processed and managed by an enterprise application, chances are you’ll be running into quite a few challenges. Here’s how you can overcome some of them.</p><h4>Downsize on purpose</h4><p>Loading large, unstructured data sets usually doesn’t serve any purpose — it doesn’t help the user and it certainly doesn’t help the performance of the system. Furthermore, if the data you are trying to load does NOT support pagination or virtualization (e.g. an IT infrastructure map), you will most probably hit a hard limit set in place by the engineering team to protect the rest of the ecosystem. To overcome this, <strong>use a tailored data segmentation or a guided user flow for each user profile</strong> — think about the most relevant and / or the most used criteria to have as an implicit filter and build on that.</p><p>For example, instead of displaying a list of all the job applications in the system, you can start by asking the user to do a preliminary filtering on the geographic region and the department he/she is interested in, or you can start directly with the newly received applications sent in the user’s attention as a default view and take it from there.</p><h4>“Divide and conquer” when possible</h4><p>You should also try to avoid loading an entire screen at once<strong> </strong>as this might lead to long(er) waiting times for the user. Instead, you can <strong>break down the screen into multiple areas or sections</strong>, each of them with its own independent loading state. This way, if the process of loading the data in a particular section fails, it will not affect the other areas, thus the user can still use the rest of interface and investigate or report that specific issue.</p><p>For example, instead of loading an entire dashboard at once with an overall loading state for the whole page, you can break it down into individual loading states for each widget (most probably they are using different APIs anyway).</p><h4>Manage the expectations</h4><p>If the expectation is that a certain operation should take <strong>a short period of time to load</strong> or to process (e.g. searching for an item), it might be a good idea to set up a reasonable timeout limit. If the operation has NOT finished loading or processing within its dedicated time frame, it might be helpful to display the partial results (i.e. found items) and inform the user that the requested operation took longer than expected. On one hand, the partial results might be enough for the user to be able to continue his journey. And, on the other hand, this might also help identify certain technical issues within the system worth reporting and / or investigating (e.g. unresponsive APIs, faulty integrations, bandwidth allocation, etc).</p><p>If the expectation is that a certain operation could take <strong>a long period of time to load</strong> or to process (e.g. generating a report), it would be nice to inform the user in advance about the expected waiting times — you can use a generic formula for this, it doesn’t have to be exact (e.g. “this might take a few minutes”). If the user decides to go ahead and execute that operation, he/she should NOT be forced to wait on that page until the operation is completed — use a global background process indicator (make sure it’s easily visible and accessible from anywhere in the application) to keep the user informed on all his pending operations and send him/her a notification when one of them has finished loading or processing (similar to a browser download manager).</p><h4>Don’t interrupt…</h4><p>From an efficiency point of view, exposing an enterprise user to loading states regardless of the task at hand is not really ideal — it creates friction and it adds up to a fragmented experience, not to mention the frustration and the (costly) implications of having to wait for every system response when you are trying to fix an urgent issue.</p><p>To bypass these and create a fluid workflow, use a contextual approach at every step and ask yourself: <strong>is this operation something that the user must wait for?</strong></p><p>If the answer is negative (e.g. adding / deleting a record or sending out a message should not force the user to wait for a system response before moving on to his/her next action), consider using the <strong>optimistic UI principles</strong>¹<strong> </strong>to increase the user’s perception of speed and efficiency: if an action has a 97–99% success rate, skip the loading / processing state, show the end result immediately, execute the action in the background and alert the user if there was an error or something else went wrong.</p><figure><img alt="A child is kicking away the loading state that was previously inserted between the action trigger and the action confirmation" src="https://cdn-images-1.medium.com/max/1024/1*10kaYCMCL1NW6lnL7tg1Bw.png" /><figcaption>Credit: <em>Denys Mishunov / Smashing Magazine</em></figcaption></figure><p>If the user must wait for the operation to be completed before moving on, manage the expectations as described previously and choose the appropriate loading state for short waiting times:</p><ul><li>If it’s absolutely necessary to block the interface whilst the new content is loading, use a “skeleton” to give an idea about the content being loaded, or another loading animation — aim for consistency though;</li><li>If you can load the new content asynchronously and let the user continue his work by not blocking the entire screen, go for a loading bar somewhere visible.</li></ul><h3>Error handling</h3><p>I know, often times this falls at the end of our “to do” list, or we skip this entirely and rely on the engineering team to handle it 😅 , but it doesn’t have to be this way if we keep in mind a few pointers.</p><p><a href="https://medium.com/u/6d3342175f2b">Jenni Nadler</a> has a wonderful take on what makes a good error message² (see the example below) — both the structure and the reasoning behind the message are spot on.</p><figure><img alt="The structure of a good error message: say what happened, provide reassurance, say why it happened, help them fix it, give them a way out." src="https://cdn-images-1.medium.com/max/1024/1*u0z91xp9KC0WlZIwK3YRUA.png" /><figcaption>Credit: Jenni Nadler / Medium</figcaption></figure><p>And it works out nicely for consumer products but, when dealing with errors in enterprise applications, it all comes down to the user’s role, permissions and the context of his actions.</p><p>For instance, <strong>does the user have the permission to see the error in the first place?</strong> There might be (rare) cases when the user has specific rights to an integration or a part of the system that only allows him/her access to certain information, which may or may not include errors (for security or compliance reasons). But, even if the user does not have enough clearance to see the errors, we still have to inform him/her that an error has occurred. In this case, we have to be generic on purpose — “Something went wrong …” is THE most representative example if you don’t want to give away any details about an error, but you should definitely change this to fit the context and level of details you are allowed to provide for that user.</p><p>Assuming the user has enough permissions to see a particular error, <strong>is he/she allowed to also see the details of that error</strong> (e.g. error code, server response, reason, etc.)? And if so, <strong>are these details relevant for him/her</strong> in any way? For example, you might want to display the error code and the server response to a power user, an administrator or even to an entire organization (e.g. IT Operations) so they can start troubleshooting the issue at hand or pass it on to the appropriate department, but there is no point in bothering an entry level user or the members of non-technical departments with these details.</p><p>The actions and indications you provide in the error messages should also follow the same pattern: <strong>match the follow-up items with the user profile and their permissions</strong>. Building on the previous example, you could include relevant links depending on the error type to “report the issue”, “check the system status” or “view documentation” for power users and administrators. For entry level users or non-technical employees, you could use more friendly actions, as seen in <a href="https://medium.com/u/6d3342175f2b">Jenni Nadler</a>’s example above: “retry” / “reload”, “contact admin ” / “contact support”, etc.</p><h3>Display data</h3><p>“How do we display data?” has to be the most generic question out there and it usually comes together with the most generic answer of all times: “it depends”. Things are no different when it comes to enterprise products, but we can definitely consider a few general use cases you should take into account.</p><h4>No data</h4><p>There are a number of scenarios that can lead to an empty state, depending on the context the user is in. Regardless, you should always aim to offer him/her a way out.</p><ul><li>Is the empty state a result of a lookup process? Then offer the user a shortcut to go back or move forward. For example, it can be that he/she used a combination of filters that resulted in no matching items — in this case, offer an “undo” option that would allow him/her to go back and automatically revert the last applied filters. Or, it can be that the user searched for a particular item but misspelled the keyword(s) — in this case, offer a few similar alternatives (based on the soundex or other relevant criteria) and allow him/her to move forward.</li><li>Does the user have enough permissions to add items for example? Then offer him/her an extra option to do so. Following the previous example, if the user is searching for a particular item with no results, you can offer an option to add a new item using the keywords he/she was searching for, in addition to providing the aforementioned alternatives.</li><li>Lastly, the empty state could be the result of a human or a system error — in this case, follow the “error handling” pointers. Avoid using the empty state as a substitute for an error message or a lack of permissions — we’ll handle the latter case in a moment.</li></ul><h4>Too little data</h4><p>(White) Space… the final frontier, the holy grail of any data-heavy product. It happens so rarely to be able to use it properly that you might be tempted to jump on your first idea and design something before stakeholders come up with more requirements you have to squeeze in 😈.</p><p>The challenge lies in delivering a good solution considering the medium or device used by the target persona. In this case, when there’s too little data to be shown, you have to <strong>keep an eye on large screen resolutions</strong> ranging from 4K monitors to muti-monitor setups. Depending on the type of content you need to display, <strong>consider Fitts’s law³</strong> at all times:</p><blockquote>“The time to acquire a target is a function of the distance to and size of the target” — in other words, the smaller the target and the further it’s placed, the harder it is to hit.</blockquote><p>For example, if you have a table with just a few columns and contextual actions on each row, placed at the right side of the table, it’s going to affect the ergonomics of using these actions properly if the table stretches for the entire width of the viewport. The same goes for a dashboard using a couple of widgets spread across the entire screen. In most cases, it might work to set up some boundaries or limits for widths, gaps, margins, etc. In other cases, you might need to rethink the way you design the same screen for multiple breaking points with higher values than usual.</p><h4>Too much data</h4><p>Opposite from the previous corner case, you might also be faced with the challenge of <strong>displaying too much data on a tiny screen resolution</strong> (you’d be amazed to find out the manufacturing date on the equipment used in some enterprises).</p><p>With limited real estate you have a few options: wrap content, horizontal scroll, content truncation with a touch of progressive disclosure, or a combination of these. Choosing the right method depends on the context, but let’s break them down using a table as an example:</p><ul><li>wrapping the content will generate too much vertical scroll (e.g. long descriptions for each item);</li><li>horizontal scroll will probably require a lot of going back and forth to get all the details of a single item;</li><li>truncation works in some cases, but it requires an additional action to see or be able to copy the content (e.g. using the “hover” or “click” events to uncover it, maybe a contextual menu to copy it, and so on);</li><li>a combination of wrapping and horizontal scroll where the least important columns are pushed towards the end of the table might work in some scenarios, whereas a combination of wrapping and truncation (to a maximum number of lines) might work well in some other cases.</li></ul><p>Bottom line: always use real data in your designs to easily uncover all these cases, especially the best and the worst scenarios. Whatever method you choose, don’t forget you should design for the majority and treat the minority separately — pick your methods accordingly.</p><h4>Protected data</h4><p>Don’t forget that different users reading the same piece of information might have different permissions — in this case, consider obfuscating the parts that they don’t have access to (instead of hiding them) and add a brief note that explains the reason. If you do hide them, you might break the context and generate confusion. For example, Slack does this with the private channels (see how it looks like below) — if you take out the “private channel” part, it doesn’t make any sense anymore.</p><figure><img alt="A private channel being obfuscated in Slack and a tooltip expalining the possible causes." src="https://cdn-images-1.medium.com/max/1024/1*7rdZUIlpgt2defCqgMm7ag.png" /></figure><h4>Format data</h4><p>Somehow similar to the previous case, users from different locations might understand different things looking at the same data. Always format the data you’re showing based on the user’s preference — keep in mind that if a user works from a particular country, it doesn’t necessarily mean he/she will automatically adopt the standard formatting used in that country.</p><p>For example, I might be an European employee temporary working from the U.S. — it doesn’t mean I want to transition automatically to miles instead of kilometers or using the `mm/dd/yyyy` date format instead of `dd/mm/yyyy`.</p><figure><img alt="Different date time formats used across the world: USA/Philippines, Australia/India, parts of Spain, east Asia, the rest of the world and ISO 8601" src="https://cdn-images-1.medium.com/max/1024/1*lhMjSK_tD-6UpDyR9otN5w.png" /></figure><h4>Sneak peek at Part 2</h4><ul><li>Take accessibility seriously;</li><li>Design for speed and repetitive use;</li><li>Plan for scalability;</li><li>Match the learning curve.</li></ul><p>👉 <a href="https://bootcamp.uxdesign.cc/designing-a-data-heavy-enterprise-application-part-2-9af9f172f0e6">Designing a data-heavy enterprise application — Part 2</a></p><h4>References</h4><ol><li><a href="https://www.smashingmagazine.com/2016/11/true-lies-of-optimistic-user-interfaces/">True Lies Of Optimistic User Interfaces</a></li><li><a href="https://wix-ux.com/when-life-gives-you-lemons-write-better-error-messages-46c5223e1a2f">When life gives you lemons, write better error messages</a></li><li><a href="https://lawsofux.com/fittss-law/">Fitts’s Law</a></li></ol><p><em>If you found this article helpful, </em><strong><em>please consider giving it a few claps </em></strong><em>👏 . You can also ping me on </em><a href="https://linkedin.com/in/ovidiuboc/"><em>LinkedIn</em></a><em> if you have any questions, I’d be glad to help.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b70c0578accd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-a-data-heavy-enterprise-application-part-1-b70c0578accd">Designing a data-heavy enterprise application — Part 1</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>