What truly makes a positive UX in any type of app

What truly makes a positive UX in any type of app

The term “app” refers to any software application that provides a user interface and functionality. This includes mobile apps, web apps, websites, desktop apps, and any other type of app. I use this term as I focus on the UX aspects that are common across all devices, platforms, and environments.

In today’s digital world, apps are essential for everything from staying connected with friends and family to getting work done... to insulting people you dislike(?). But with so many apps to choose from, it can be difficult to stand out from the crowd. The key is to deliver a positive UX to your users.

An app with a positive UX means it’s an app that a large and diverse group of users gladly keep coming back to. But what makes an app so satisfying? What truly makes a positive UX in any type of app? Well, the short answer is...
Alright, I guess the long answer is needed...


This is the most basic element for any app. It means that the app does what it is supposed to do, and does it well. It also means that the app has no noticeable bugs/glitches, and it meets the needs of the target users. Functionality is closely related to usability, which we will discuss later.

How to achieve high functionality, very generally

  • Make it productive by meeting user needs. Understand what the user genuinely needs to do with the app, and then publish a product requirements document (PRD) that matches those needs.

  • Make it streamlined by adopting the right architecture and/or sys design that suits the business requirements and user expectations. Compare, research, illustrate, present, brainstorm, etc. - before(!) the actual development process.

  • Make it supervised by utilizing an organized release cycle. Ensure that all teams are doing what they are supposed to do, at a reasonable pace, and that their deliverables are solid. The released content should match both your capabilities (as an organization) and the needs of the users, in that particular cycle. This helps to manage the expectations of the users and the stakeholders.

  • Make it reliable by conducting E2E and integration tests, monitoring their results, reporting and eliminating the caught defects - before(!) releasing the app to the public.

  • Make it progressive by iterating the UX based on user feedback, while not expecting to get everything right upon initial public release.


This is the measure of how inclusive and universal the app is. It means that the app can be used by people with different abilities, preferences, and backgrounds. It also means that the app adapts to different devices, platforms, and environments. Accessibility is not only a moral obligation, but also a legal requirement in many countries.

How to achieve high accessibility, very generally

  • Make it compliant by following the Web Content Accessibility Guidelines (WCAG), a set of guidelines that define how to make web content more accessible to people with disabilities.

  • Make it configurable (visual-wise) by displaying some accessibility settings to users. Implement a GUI component that is populated with options that control the graphics, e.g. text size, contrast ratio, color scheme, etc., mainly for users with disabilities or temporary/situational impairments.

  • Make it semantic by making your web pages semantic (if it’s a web app). Use the most suitable HTML elements and attributes (including WAI-ARIA), which helps assistive technologies understand the structure and hierarchy of the page. It is also good for SEO, by the way.

  • Make it inclusive by adopting inclusive design. Consider the needs of all users, whoever and wherever they are. This means thinking about stuff like color schemes (incl. contrast ratio), keyboard+mouse interactions, assistive tech, and typography from the very beginning of the design process.

  • Make it empowering by empathizing with your users. Inspect the app with a diverse and wide group of real-world users. This means involving users from a variety of backgrounds and abilities to test the app across different testing sessions, and modifying it according to their limitations, desires and needs.


This is the measure of how trustworthy and reputable the app is. It means that the app provides accurate and reliable information, follows best practices and standards, and has a clear and consistent identity. It also means that the app builds a positive relationship with the user, by being transparent, honest, and respectful.

How to achieve high credibility, very generally

  • Be transparent by being open and honest about your app, its features, and its limitations, and by being genuine about how you collect and use user data.

  • Be accountable by being responsible for your app and its actions, and by being responsive to user feedback and taking steps to address any issues that are raised.

  • Be accurate by providing the users with info/data that is correct and up-to-date, that can help the user make solid decisions, rather than poor ones.

  • Be clear by using audience-aware jargon. Utilize a language that is appropriate for the specific audience you are addressing.

  • Be instructive by displaying widely accepted cues in the form of glyphs, icons and colors, especially in user tasks/flows that involve sensitive data. Try to lean towards the positive cues, rather than the negative ones.


This is the measure of how easy and intuitive the app is to use. It means that the app follows the user’s mental model, provides clear and helpful feedback, and supports the user’s goals and tasks. It also means that the app minimizes cognitive load, prevents user errors (ahead of time), and enhances satisfaction.

How to achieve high usability, very generally

  • Make it easy to learn by providing an onboarding process for new users, which is the process of getting users familiar with the app and how to use it. Aspire for this process to be very straightforward, so that users can start using the app quickly and without getting frustrated.

  • Make it easy to use by following the principles of user-centered design. These principles include making the app predictable, clear, consistent, fast, and human-friendly. The app should also use familiar colors, shapes, layouts, and patterns that do not require much effort or cognitive load from the user.

  • Make it time-saving by allowing the user to complete tasks and flows quickly. Also, if you can get him/her to the "finish line" with very few interactions, do it.

  • Make it enjoyable by providing a visually appealing GUI, and in some cases humor.

  • Make it error-preventing by validating user input, providing feedback/hints, and using smart default values.


This is the measure of how resilient and scalable the app is. It means that the app can handle high concurrency, load balancing, and fault tolerance. It also means that the app can adopt continuous integration (CI) and continuous delivery (CD) practices to enable rapid and/or big changes based on user feedback and market demands.

In the world of software dev, many consider this as Reliability, but Reliability actually refers to the number of defects in the app, i.e. the overall quality. That’s why I think Durability is the suitable word here.

How to achieve high durability, very generally

  • Make it scalable by ensuring that the infrastructure can handle increasing traffic and load without sacrificing performance, typically via distributed database, containerization platform, and a monitoring system.

  • Make it fault-tolerant by allowing the app to function even during a failure, typically via redundant components and failover mechanisms.

  • Make it flood-proof by being able to handle many user requests parallelly, typically via a load balancer and a caching mechanism.

  • Make it balanced (load-ready) by being able to distribute traffic evenly across multiple servers, typically via load testing procedures and load balancer.

  • Make it stressless by stress-testing the system’s capacity and setting certain limits accordingly, such as X number of max requests in a given time range.

  • Make it deployable by utilizing CI/CD pipelines. Make sure that the app can be easily and quickly released to the public, and that it can be updated and modified without much hassle.


This is the measure of how safe and secure the app is. It means that the app protects the user’s data and privacy, prevents unauthorized access, and follows ethical standards. Security is also related to credibility, which we will discuss later.

How to achieve high invulnerability, very generally

  • Make it camouflaged by converting data into a form that is unreadable by unauthorized users, which is essential for protecting sensitive data (e.g. passwords, card numbers, etc.). This can be achieved by using a strong encryption algorithm and a secure key management process.

  • Make it armored by using a firewall and blocking incoming traffic from certain IP addresses or ports, typically via security devices that protect corporate networks and data centers.

  • Make it monitored by actively hunting for vulnerabilities. Automatically and regularly detect security holes, typically via a vulnerability scanner.

  • Be prepared for the worst by conducting pen testing and simulating cyberattacks on the system, and by adopting secure coding practices such as OWASP Top 10 security vulnerabilities.


This is the measure of how swift and responsive (not to be confused with responsive layouts!) the app is. It means that the app loads quickly, responds to user inputs without delay, and handles complex tasks efficiently. Agility is also related to accessibility, which we discussed earlier.

How to achieve high agility, very generally

  • Make it asynchronous by utilizing concurrency. Execute several tasks and services simultaneously on different threads/processes, instead of blocking the primary one.

  • Make it data-ready by caching frequently used data and operating a good DB system. Store artifacts (images, fonts, etc.) locally on the device, instead of fetching it from the server every time. And efficiently handle a large volume of real-time data, including extra-large "chunks" of data.

  • Make it lightweight by utilizing smart compression. Use the right file formats and sizes per case, and/or compress data efficiently.

  • Make it punctual (calculations-based) by conducting performance testing. Measure the durations of flows, processes, and requests, and identify performance bottlenecks, typically via special-purpose testing tools and libraries.

So, a great app is...

  • Highly functional (excels in what it’s meant to do).

  • Highly accessible (inclusive & universal).

  • Highly credible (trustworthy).

  • Highly usable (helpful & appealing).

  • Highly durable (resistant).

  • Highly invulnerable (secured).

  • Highly agile (performant).

A great app has FACUDIA.

FACUDIA is a term I made up. It stands for the 7 elements of positive UX: Functionality, Agility, Credibility, Usability, Durability, Invulnerability, and Accessibility. I use this term to help you remember these elements, but this term is not official or widely accepted. Please use it with care and credit.

Creating a great app is not a walk in the park

Sorry to be that party pooper, but achieving all of the above (i.e. FACUDIA) is a pain in the neck. It requires a lot of resources from companies, such as money, time, planning, skills, and much more. But these are not roadblocks, they are just potholes and bumps along the way. It can be overcome with hard work, passion, and innovation. Many companies have done it before, while facing many difficulties and failures along the way. They had to deal with things like user feedback, market demands, security threats, performance issues, and accessibility standards.

Moreover, the company doesn’t need to start from scratch, as it already has some expertise in at least 3 out of the 7 elements above, most likely. And there’s no need to nail it on the first tries. The company can tweak and polish its app based on user feedback and market trends across several public releases, just like big corporations are doing with their apps.

And always remember:
A positive UX is expensive, a negative UX is a financial nightmare.