The Human Element: Using Research And Psychology To Elevate Data Storytelling The Human Element: Using Research And Psychology To Elevate Data Storytelling Victor Yocco & Angelica Lo Duca 2025-02-26T10:00:00+00:00 2025-03-04T21:34:45+00:00 Data storytelling is a powerful communication tool that combines data analysis with narrative techniques to […]
UxHow To Test And Measure Content In UX How To Test And Measure Content In UX Vitaly Friedman 2025-02-13T08:00:00+00:00 2025-03-04T21:34:45+00:00 Content testing is a simple way to test the clarity and understanding of the content on a page — be it a paragraph of text, […]
UxThe Role Of Illustration Style In Visual Storytelling The Role Of Illustration Style In Visual Storytelling Thomas Bohm 2025-01-14T08:00:00+00:00 2025-03-04T21:34:45+00:00 Illustration has been used for 10,000 years. One of the first ever recorded drawings was of a hand silhouette found in Spain, that is more […]
UxAlternatives To Typical Technical Illustrations And Data Visualisations Alternatives To Typical Technical Illustrations And Data Visualisations Thomas Bohm 2024-11-08T09:00:00+00:00 2025-03-04T21:34:45+00:00 Good technical illustrations and data visualisations allow users and clients to, in a manner of speaking, take time out, ponder and look at the information […]
Ux
2024-11-08T09:00:00+00:00
2025-03-04T21:34:45+00:00
Good technical illustrations and data visualisations allow users and clients to, in a manner of speaking, take time out, ponder and look at the information in a really accessible and engaging way. It can obviously also help you communicate certain categories of information and data.
The aim of the article is to inspire and show you how, by using different technical illustrations and data visualisations, you can really engage and communicate with your users and do much more good for the surrounding content.
Below are interesting and not commonly seen examples of technical illustration and data visualisation, that show data and information. As you know, more commonly seen examples are bar graphs and pie charts, but there is so much more than that!
So, keep reading and looking at the following examples, and I will show you some really cool stuff.
Typically, technical illustration and data visualisations were done using paper, pens, pencils, compasses, and rulers. But now everything is possible — you can do analog and digital. Since the mainstream introduction of the internet, around 1997, data (text, numerical, symbol) has flourished, and it has become the current day gold currency. It is easy for anyone to learn who has the software or knows the coding language. And it is much easier to do technical illustrations and data visualisation than in previous years. But that does not always mean that what is done today is better than what was done before.
There are some common categories of audiences:
Sara Dholakia in her article “A Guide To Getting Data Visualization Right” points out the following considerations:
Just look at what we are more often than not presented with.
So, let us dive into some cool examples that you can understand and start using today that will also give your work and content a really cool edge and help it stand out and communicate better.
It provides a great way to show relationships and connections between items and different components, and the 3D style adds a lot to the diagram.
It’s an effective way to highlight and select information or data in relation to its surrounding data and information.
Being great at showing two categories of information and comparing them horizontally, they are an alternative to typical horizontal or vertical bar graphs.
They are an excellent way to enliven overused 2D pie and bar graphs. 3D examples of common graphs give a real sense of quality and depth whilst enhancing the data and information much more than 2D versions.
This diagram is a good way to show the progression and the journey of information and data and how they are connected in relation to their data value. It’s not often seen, but it’s really cool.
A stream graph is a great way to show the data and how it relates to the other data — much more interesting than just using lines as is typically seen.
It provides an excellent way to show a map in a different and more interesting form than the typically seen 2D version. It really gives the map a sense of environment, depth, and atmosphere.
It’s a great way to show the data spatially and how the data value relates, in terms of size, to the rest of the data.
A waterfall chart is helpful in showing the data and how it relates in a vertical manner to the range of data values.
It shows the data against the other data segments and also as a value within a range of data.
A lollipop chart is an excellent method to demonstrate percentage values in a horizontal manner that also integrates the label and data value well.
It’s an effective way to illustrate data values in terms of size and sub-classification in relation to the surrounding data.
There are many options available, including specialized software like Flourish, Tableau, and Klipfolio; familiar tools like Microsoft Word, Excel, or PowerPoint (with redrawing in software like Adobe Illustrator, Affinity Designer, or CorelDRAW); or learning coding languages such as D3, Three.js, P5.js, WebGL, or the Web Audio API, as Frederick O’Brien discusses in his article “Web Design Done Well: Delightful Data Visualization Examples.”
But there is one essential ingredient that you will always need, and that is a mind and vision for technical illustration and data visualisation.
Designing For Gen Z: Expectations And UX Guidelines Designing For Gen Z: Expectations And UX Guidelines Vitaly Friedman 2024-10-30T09:00:00+00:00 2025-03-04T21:34:45+00:00 Every generation is different in very unique ways, with different habits, views, standards, and expectations. So when designing for Gen Z, what do we need […]
Ux
2024-10-30T09:00:00+00:00
2025-03-04T21:34:45+00:00
Every generation is different in very unique ways, with different habits, views, standards, and expectations. So when designing for Gen Z, what do we need to keep in mind? Let’s take a closer look at Gen Z, how they use tech, and why it might be a good idea to ignore common design advice and do the opposite of what is usually recommended instead.
.course-intro{–shadow-color:206deg 31% 60%;background-color:#eaf6ff;border:1px solid #ecf4ff;box-shadow:0 .5px .6px hsl(var(–shadow-color) / .36),0 1.7px 1.9px -.8px hsl(var(–shadow-color) / .36),0 4.2px 4.7px -1.7px hsl(var(–shadow-color) / .36),.1px 10.3px 11.6px -2.5px hsl(var(–shadow-color) / .36);border-radius:11px;padding:1.35rem 1.65rem}@media (prefers-color-scheme:dark){.course-intro{–shadow-color:199deg 63% 6%;border-color:var(–block-separator-color,#244654);background-color:var(–accent-box-color,#19313c)}}
This article is part of our ongoing series on UX. You can find more details on design patterns and UX strategy in Smart Interface Design Patterns 🍣 — with live UX training coming up soon. Free preview.
When we talk about Generation Z, we usually refer to people born between 1995 and 2010. Of course making universal statements about a cohort where some are adults in their late 20s and others are school students is at best ineffective and at worst wrong — yet there are some attributes that stand out compared to earlier generations.
Gen Z is the most diverse generation in terms of race, ethnicity, and identity. Research shows that young people today are caring and proactive, and far from being “slow, passive and mindless” as they are often described. In fact, they are willing to take a stand and break their habits if they deeply believe in a specific purpose and goal. Surely there are many distractions along that way, but the belief in fairness and sense of purpose has enormous value.
Their values reflect that: accessibility, inclusivity, sustainability, and work/life balance are top priorities for Gen Zs, and they value experiences, principles, and social stand over possessions.
Gen Z grew up with technology, so unsurprisingly digital experiences are very familiar and understood by them. On the other hand, digital experiences are often suboptimal at best — slow, inaccessible, confusing, and frustrating. Plus, the web is filled with exaggerations and generic but fluffy statements. So it’s not a big revelation that Gen Zs are highly skeptical of brands and advertising by default (rightfully so!), and rely almost exclusively on social circles, influencers, and peers as main research channels.
They might sometimes struggle to spot what’s real and what’s not, but they are highly selective about their sources. They are always connected and used to following events live as they unfold, so unsurprisingly, Gen Z tends to have little patience.
And sure enough, Gen Z loves short-form content, but that doesn’t necessarily equate to a short attention span. Attention span is context-dependent, as documentaries and literature are among Gen Z’s favorites.
Most design advice on Gen Z focuses on producing “short form, snackable, bite-sized” content. That content is optimized for very short attention spans, TikTok-alike content consumption, and simplified to the core messaging. I would strongly encourage us to do the opposite.
We shouldn’t discount Gen Z as a generation with poor attention spans and urgent needs for instant gratification. Gen Zs have very strong beliefs and values, but they are also inherently curious and want to reshape the world. We can tell a damn good story. Captivate and engage. Make people think. Many Gen Zs are highly ambitious and motivated, and they want to be challenged and to succeed. So let’s support that. And to do that, we need to remain genuine and authentic.
As Michelle Winchester noted, Gen Zs have very diverse perspectives and opinions, and they possess a discerning ability to detect disingenuous content. That’s also where mistrust towards AI comes into play, along with AI fatigue. As Nilay Patel mentioned on Ezra Klein Show, today when somebody says that something is “AI-generated”, usually it’s not a praise, but rather a testament how poor and untrustworthy it actually is.
Gen Z expects better. Hence brands that value sincerity, honesty, and authenticity are perceived as more trustworthy compared to brands that don’t have an opinion, don’t take a stand, don’t act for their beliefs and principles. For example, the “Keep Beauty Real” campaign by Dove (shown below) showcases the value of genuine human beauty, which is so often missed and so often exaggerated to extremes by AI.
So whenever you can, aim for the opposite of perfect. Say what you think and do what you promise. Reflect the real world with real people using real products, however imperfect they are. That’s how you build a strong relationship and trust with Gen Z.
Because Gen Z are so incredibly diverse, their needs are extremely diverse and demanding as well. This doesn’t necessarily mean customization of features or adapting the layout entirely based on custom settings or preferences. But it does mean providing an accessible experience out of the box.
Simple things matter. High enough color contrast. Links that look like links. Buttons that look like buttons. Forms that are broken down into simple steps to follow. Diverse gender and identity options. Proper tab order. Keyboard accessibility. Reduced motion for people who opt in for reduced motion sickness. Dark mode and light mode.
It’s nothing groundbreaking really. Just basic things that help focus and get things done. In fact, accessibility is better for everyone — not just for Gen Z (who expect and demand it) but also for absolutely everybody around the world.
Many design mock-ups that we are creating today are typically designed and presented on large screens first. However, depending on your user base, a vast majority of users (and that’s especially true for Gen Zs), will use almost exclusively mobile devices to access your products and services. This surely will be different for enterprise software, but consumer products are much less likely to be used on desktop devices by younger Gen Zs.
Get into the habit of presenting your design mock-ups in mobile views only first. Help people read better. Content design has never been more important — especially when designing for mobile screens. Here are a few guidelines to keep in mind:
Many people, and especially Gen Z, turn on closed captioning by default these days. Perhaps the spoken language isn’t their native language, or perhaps they aren’t quite familiar with the accent of some speakers, or maybe they don’t have headphones nearby, don’t want to use them, or can’t use them. In short, closed captions are better for everybody and they increase ROI and audience.
Gareth Ford Williams has put together a visual language of closed captions and has kindly provided a PDF cheatsheet that is commonly used by professional captioners. There are some generally established rules about captioning, and here are some that I found quite useful when working on captioning for my own video course:
On YouTube, users can select a font used for subtitles and choose between monospaced and proportional serif and sans-serif, casual, cursive, and small-caps. But perhaps, in addition to stylistic details, we could provide a careful selection of fonts to help audiences with different needs. This could include a dyslexic font or a hyper-legible font, for example.
Additionally, we could display presets for various high contrast options for subtitles. This gives users a faster selection, requiring less effort to configure just the right combination of colors and transparency. Still, it would be useful to provide more sophisticated options just in case users need them.
On the other hand, in times of instant gratification with likes, reposts, and leaderboards, people often learn that a feeling of achievement comes from extrinsic signals, like reach or attention from other people. The more important it is to support intrinsic motivation.
As Paula Gomes noted, intrinsic motivation is characterized by engaging in behaviors just for their own sake. People do something because they enjoy it. It is when they care deeply for an activity and enjoy it without needing any external rewards or pressure to do it.
Typically this requires 3 components:
In practical terms, that means setting people up for success. Preparing the knowledge and documents and skills they need ahead of time. Building knowledge up without necessarily rewarding them with points. It also means allowing people to have a strong sense of ownership of the decisions and the work they are doing. And adding collaborative goals that would require cooperation with team members and colleagues.
The younger people are, the more difficult it is to distinguish between what’s real and what isn’t. Whenever possible, show sources or at least explain where to find specific details that back up claims that you are making. Encourage people to make up their mind, and design content to support that — with scientific papers, trustworthy reviews, vetted feedback, and diverse opinions.
And: you don’t have to shy away from technical details. Don’t make them mandatory to read and understand, but make them accessible and available in case readers or viewers are interested.
In times where there is so much fake, exaggerated, dishonest, and AI-generated content, it might be just enough to be perceived as authentic, trustworthy, and attention-worthy by the highly selective and very demanding Gen Z.
I keep repeating myself like a broken record, but better accessibility is better for everyone. As you hopefully have noticed, many attributes and expectations that we see in Gen Z are beneficial for all other generations, too. It’s just good, honest, authentic design. And that’s the very heart of good UX.
What I haven’t mentioned is that Gen Z genuinely appreciates feedback and values platforms that listen to their opinions and make changes based on their feedback. So the best thing we can do, as designers, is to actively involve Gen Z in the design process. Designing with them, rather than designing for them.
And, most importantly: with Gen Z, perhaps for the first time ever, inclusion and accessibility is becoming a default expectation for all digital products. With it comes the sense of fairness, diversity, and respect. And, personally, I strongly believe that it’s a great thing — and a testament how remarkable Gen Zs actually are.
I’ve just launched “How To Measure UX and Design Impact” 🚀 (8h), a new practical guide for UX leads to measure UX impact on business. Use the code 🎟 IMPACT
to save 20% off today. And thank you for your kind and ongoing support, everyone! Jump to details.
Managing multiple PHP versions is a common challenge when developing PHP applications, where applications often require different versions due to varying framework dependencies and compatibility requirements. While switching between PHP versions can be daunting, especially at the system level, several tools can streamline this process. […]
CodingManaging multiple PHP versions is a common challenge when developing PHP applications, where applications often require different versions due to varying framework dependencies and compatibility requirements. While switching between PHP versions can be daunting, especially at the system level, several tools can streamline this process.
In this article, we’ll explore effective solutions for managing multiple PHP versions, helping you choose the right tool to simplify your development workflow. So, without further ado, let’s get started.
.no-js #ref-block-post-47222 .ref-block__thumbnail { background-image: url(“https://assets.hongkiat.com/uploads/thumbs/250×160/how-to-upgrade-php.jpg”); }
PHP7.4 has been released with a handful of new features — like the arrow function array_map(fn (Foo $foo)… Read more
Homebrew, the popular package manager for macOS and Linux, simplifies PHP version management. After installing Homebrew from their official website, follow these steps to set up and switch between PHP versions:
To manage multiple PHP versions with Homebrew, we’ll first tap into Shivam Mathur’s widely-used PHP repository. This repository provides access to various PHP versions that you can install:
brew tap shivammathur/php
Once the repository is tapped, you can install your desired PHP versions. Here’s how to install PHP 7.4, 8.2, and the latest version (currently 8.3):
brew install shivammathur/php/php@7.4 brew install shivammathur/php/php@8.2 brew install shivammathur/php/php
Feel free to install any combination of versions that your projects require. Each version will be stored separately on your system.
While Homebrew allows you to install multiple PHP versions simultaneously, your system can only use one version at a time through its PATH
. Think of it like having multiple PHP versions installed in your toolbox, but only one can be your active tool.
Let’s assume you are currently running PHP 8.3, but now you need to switch to PHP 7.4. First, unlink the current version to “disconnect” the currently active PHP version from PATH
.
brew unlink php
After unlinking the current version, you can link the other version using the brew link
command:
brew link php@7.4
Now, when you run php -v
, it will show the active PHP version as 7.4, as you can see below.
Homebrew makes it easy to use multiple PHP versions on macOS and Linux through the CLI. But it also comes with its own set of pros and cons. So consider the following when deciding if Homebrew is the right choice for you.
PHP Monitor is a lightweight macOS application designed to help developers manage and switch between different PHP versions easily. It offers a familiar and intuitive UI that appears at the top of your screen, allowing you to switch between PHP versions with a single click. This app integrates with Homebrew, making it easier to manage your PHP setup without using the terminal.
As we can see above, you can view which PHP versions are installed on your machine, the current version active globally, access the PHP configuration file, view the memory limit, and more.
The app also provides a simple way to install and update PHP versions from the Manage PHP Installations… menu.
.phpctlrc
file to switch between PHP versions.PHPCTL is a tool designed to help developers easily switch between different PHP versions by leveraging Docker containers. This makes PHPCTL portable and platform-independent, allowing you to manage PHP versions on any operating system that supports Docker. It also provides additional CLI tools, such as phpctl create
for new projects, phpctl repl
for interactive shells, and phpctl init
for configuration setup, among other handy features.
Before getting started, you’ll need Docker installed on your system. Docker Desktop works great, or if you’re on macOS, you might prefer OrbStack.
Once you have Docker installed, you can install PHPCTL using the following command:
/bin/bash -c "$(curl -fsSL https://phpctl.dev/install.sh)"
Or, if you have Homebrew installed, you can run:
brew install opencodeco/phpctl/phpctl
This will download the PHPCTL binary to your system and make it executable, allowing you to use the tool right away. The script automatically installs PHPCTL and sets up the necessary paths, so no manual configuration is required.
After installation, you can check if it was successfully installed by running:
phpctl list
This command will list all the subcommands and other information about the current PHP installation, as you can see below.
You can also run the php
and composer
commands directly.
php -v composer -v
These two commands will actually run inside a Docker container. PHPCTL will automatically mount the current directory to the container, so you can work on your project as if you were working on your local machine.
Unlike with Homebrew or PHP Monitor, where you need to run a command or click on the UI to switch to the PHP version, with PHPCTL, you will need to create a file .phpctlrc
and specify which PHP version you’d like to run within the given directory.
PHP_VERSION=83
When you run php
or composer
in the directory, PHPCTL will automatically switch to the PHP version specified in the .phpctlrc
file.
That’s all. It’s very convenient and provides a seamless development experience once it is fully configured. However, it also comes with its own set of pros and cons.
PVM simplifies PHP version management on Windows. Similar to Node Version Manager (nvm) but specifically for PHP, PVM eliminates common Windows PATH
variable headaches and streamlines switching between different PHP versions.
Download the latest PVM release from the official Github repository. Then, create a folder at C:UsersYourUsername.pvmbin
and place the downloaded pvm.exe
in this folder.
Lastly, add the .pvmbin
folder to your system’s PATH
variable through System Properties > Environment Variables.
Once installed, you can use PVM to switch between PHP versions quickly and easily. Since it is heavily inspired by nvm, the commands are similar. Here are some commands to get you started:
PVM makes it easier to install multiple PHP versions on Windows. If you need a version that’s not currently installed on your computer, you can use the install command:
pvm install 8.2
…which will download and install PHP 8.2 on your computer.
If you want to switch to a specific PHP version, use the use command. You must specify at least the major and minor version, and PVM will choose the latest available patch version if it’s not provided.
pvm use 8.2
If you want to switch to a specific patch version, include the patch number as well:
pvm use 8.2.3
That’s all. PVM is a great tool for managing PHP versions on Windows, but it also comes with its own set of pros and cons.
Laravel Valet is a lightweight development environment designed specifically for macOS that makes PHP development a breeze. What makes Valet particularly convenient is its built-in PHP version management that allows you to switch between PHP versions for different projects without complex configurations.
To get started, install Valet using Composer as a global package:
composer global require laravel/valet
After installation, run the Valet installation command:
valet install
Valet makes PHP version switching simple with the valet use php@version
command. For example:
valet use php@8.2
It automatically installs the version via Homebrew if it’s currently missing.
For project-specific PHP versions, you can create a .valetrc
file in your project’s root directory with the line php=php@8.2
. Then, simply run:
valet use
…and Valet will automatically switch to the PHP version specified in the .valetrc
file.
With the right tools, managing multiple PHP versions becomes effortless across macOS, Linux, or Windows. Hopefully, this article helps you pick the solution that matches your workflow.
The post 5 Ways to Manage Multiple Versions of PHP appeared first on Hongkiat.
In our previous article, we covered how to create simple pages in Flask and use Jinja2 as the templating engine. Now, let’s explore how Flask handles requests. Understanding how HTTP requests work and how to manage them in Flask is key, as this allows you […]
CodingIn our previous article, we covered how to create simple pages in Flask and use Jinja2 as the templating engine. Now, let’s explore how Flask handles requests.
Understanding how HTTP requests work and how to manage them in Flask is key, as this allows you to build more interactive and dynamic web apps, such as building a form, API endpoints, and handling file uploads.
Without further ado, let’s get started.
An HTTP request is a message sent, usually by a browser, to the server asking for data or to perform an action. For example, when you visit a webpage, your browser sends a GET request to the server to retrieve the page’s content.
There are several different types of HTTP requests, and Flask can handle all of them, including GET
to retrieve data, POST
to send data to the server like submitting a form, PUT
to update existing data on the server, and DELETE
to delete data from the server.
Flask makes handling requests straightforward by using routes. In our previous articles, we used routes to create static and dynamic pages. By default, routes only respond to GET
requests, but you can easily handle other HTTP methods by specifying them in the route.
Assuming we have a contact page at /contact
, we probably would want the page to handle both GET
and POST
requests to allow users to load the page, as well as to submit the form. To make the page handle these two HTTP methods, we can pass in the methods
argument, for example:
@app.route('/contact', methods=['GET', 'POST']) def submit(): if request.method == 'POST': data = request.form['input_data'] return render_template('contact.html', data=data) return render_template('contact.html')
In this example, users can load the /contact
page. When the form is submitted, Flask retrieves the form data and passes it to the contact.html
template. Then, within the template, you can access and process the data using Jinja2 templating.
Data may be passed to a URL via query parameters. This is commonly found on a search page where the search query is passed as a query parameter. These are the parts of the URL after a ?
, like /search?query=flask
. Flask makes it easy to access query parameters with the request.args
dictionary, for example:
@app.route('/search') def search(): query = request.args.get('query') # Meilisearch # See: https://github.com/meilisearch/meilisearch-python result = index.search(query) if query: return render_template('search.html', result=result) return 'No search query provided.'
In this case, when a user visits /search?query=flask
, we take the query and use it to retrieve the search result, which is then passed to the search.html
template for rendering.
When building an API, we need the data delivered in JSON format. Flask provides a simple way to handle JSON data in requests with the jsonify
function. Here’s an example of handling JSON data:
from flask import jsonify @app.route('/api/data') def api_data(): return make_response(jsonify({"message": 'Success'}), 200)
Flask also makes handling file uploads easy, using the request.files
object.
@app.route('/upload', methods=['GET', 'POST']) def upload_file(): if request.method == 'POST': file = request.files['file'] file.save(f'/uploads/{file.filename}') return redirect(url_for('index.html'))
In this example, when a user submits a file via the form, Flask saves the file to the specified directory and then redirects the user to the homepage.
Sometimes you also need to get headers or cookies from the request in your app, such as for passing authentication or tracking user data. Flask provides easy access to headers through request.headers
and cookies through request.cookies
. Here’s a basic example of how we use it to authenticate for an API endpoint:
@app.route('/api/data') def check(): auth = request.headers.get('Authorization') nonce = request.cookies.get('nonce') # Simple authentication check if auth == 'Bearer X' and nonce == 'Y': return jsonify({"message": "Authenticated"}), 200 else: return jsonify({"message": "Unauthorized"}), 401
Flask makes handling HTTP requests a breeze. Whether you’re working with basic GET
requests, handling form submissions with POST
, or dealing with more complex scenarios like JSON data and file uploads, it provides the APIs, functions, and tools you need to get the job done. We’ve only scratched the surface of Flask’s request-handling capabilities, but hopefully, this gives you a solid foundation to start building your own Flask apps.
The post How to Handle HTTP Requests in Flask appeared first on Hongkiat.
JavaScript continues to grow and evolve. While new libraries are important, there’s much more happening. The language itself is improving, there’s a lot going on in the community, and the tools are rapidly advancing. Let’s take a look at what’s new in JavaScript. Vue.js Creator’s […]
CodingJavaScript continues to grow and evolve. While new libraries are important, there’s much more happening. The language itself is improving, there’s a lot going on in the community, and the tools are rapidly advancing.
Let’s take a look at what’s new in JavaScript.
Evan You, who created the popular Vue.js framework, has launched a new company called VoidZero. The company recently raised $4.6 million, led by Accel.
VoidZero is working on new tools to make JavaScript development faster and easier. Their main project, called Oxc, aims to help developers write and test code more efficiently.
The company plans to release its first tool, Rolldown, later this year. This tool will work with Vite, another popular development tool. By 2025, they plan to release more features to help make JavaScript code run better and faster.
They also plan to offer special versions of their tools for larger companies that need additional features.
Read more: VoidZero Announcement
Next.js 15 introduces key updates, including the @next/codemod tool for seamless upgrades, Turbopack for faster development, and Async Request APIs for improved rendering and caching. The release also enhances security with Server Actions, adds a Static Indicator for static route visibility, and offers TypeScript support in next.config.ts. Additional improvements include faster builds, better Fast Refresh, and expanded linting support with ESLint 9.
Check out the full release here: Next.js 15 RC 2.
Inertia.js v2.0 makes building apps smoother with some exciting new features! It now supports polling to automatically check for updates, and prefetching, which helps load data for upcoming pages in the background. You can also use deferred props to speed up page loads by delaying non-essential data, and “infinite scrolling” to merge content instead of overwriting it. Plus, it supports lazy loading of data when you scroll, and there’s a new history encryption API to clear sensitive data when logging out for better security.
Keep in mind that Inertia.js 2.0 is still in beta, at the time of writing, so there may be some bugs. But it’s definitely worth checking out, especially if you’re planning to upgrade your Inertia.js application.
Check out the full release here: Inertia.js 2.0.
Express.js, a popular tool for building websites, has just released version 5.0.0 — its first major update since 2014.
The update focuses on keeping things simple and stable. The biggest change is that Express.js will now only work with newer versions of Node.js (version 18 and up). This means older websites will need to upgrade their systems to continue using Express.js.
The team made this change to make Express.js faster and easier to maintain. They also wanted to show everyone that Express.js is active again. The update includes enhanced security features and support for newer coding methods, like Promises.
This update is important for web developers who use Express.js to build websites. They’ll need to check if their websites require updates to work with the new version.
Check out the full release: Introducing Express v5: A New Era for Node.js Framework.
React Aria, a popular React library for building accessible components, has released several new features. The most significant update is a set of seven new color picker tools that are now available for everyone to use.
These color pickers are specially designed to work well with screen readers, making websites more accessible for users with visual impairments. Developers can customize how these color pickers look and function on their websites.
The update also includes new features for buttons. Developers can now add loading spinners to buttons to indicate when an action is taking place after a click.
React Aria is also testing new tools for building expandable menus and tree-like navigation structures. These features are still in testing but will help developers create more organized website navigation.
Shadcn has added a new sidebar component to their UI library. This component helps developers create sidebars for their websites more easily. It works with various website frameworks like Next.js, Remix, Vite, and Laravel. It has been built and tested with over 30 different sidebar styles, making it highly customizable for different use cases.
The post What’s New in JavaScript (2024) appeared first on Hongkiat.
Flask is a lightweight web framework for Python that makes it easy to build web applications. In our previous article, we’ve seen how to set up a simple page. But, it’s just a simple text like “Hello Flask!”. In real applications, you’ll want to render […]
CodingFlask is a lightweight web framework for Python that makes it easy to build web applications. In our previous article, we’ve seen how to set up a simple page.
But, it’s just a simple text like “Hello Flask!”. In real applications, you’ll want to render more than just simple text. You’ll want to render HTML templates.
In Flask, we can do so with Jinja.
One of its powerful features is the ability to render HTML templates using the Jinja templating engine.
Jinja templates are written in regular HTML that you are already familiar with. But, on top of that, you can use special syntax to handle dynamic content, such as for passing data from requests or other code sources to the template. It also allows you to use control structures like loops and conditionals.
Let’s see how it works in its basic form:
<!DOCTYPE html> <html> <head> <title>Welcome to Flask</title> </head> <body> {% if user.is_logged_in %} <p>Welcome back, {{ user.name }}!</p> {% else %} <p>Please log in to continue.</p> {% endif %} </body> </html>
It looks like a regular HTML file, but as we can see, we use some special syntax, such as the {{ }}
to insert a variable, and we use {% %}
for adding loops and conditionals.
To render the template, we need to put it in the templates
directory.
. |-- app.py |-- templates |-- about.html |-- index.html
Then, we use the render_template
function in our Python app file to render HTML templates. If we extend the same code from our previous article, our code would now look like the following:
from flask import Flask, render_template app = Flask(__name__) @app.route('/') def home(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html')
In our template above, we have {{ name }}
and {{ user.is_logged_in }}
variables. But, we haven’t passed any variables to the template yet.
To pass variables to the template, we can do so by passing them as arguments to the render_template
function.
For example:
@app.route('/') def home(): return render_template('index.html', user={'is_logged_in': True, 'name': 'Joann'})
Now, when we visit the home page, we will see the “Welcome back, Joann!” message instead of “Please log in to continue.” because the is_logged_in
is set to True
.
Jinja allows you to use template inheritance, which is helpful when multiple pages share the same layout or components. Instead of repeating common elements, we can create a base template and reuse it in other templates.
In this example, we have a homepage and an about page that share the same layout, like the head
, title
, and maybe some styles or scripts later on. With template inheritance, we can make things simpler and more organized.
First, we create the base file. Let’s name it base.html
. Then, add the common elements:
<!DOCTYPE html> <html> <head> <title>{% block title %}Welcome to Flask{% endblock %}</title> </head> <body> {% block content %}{% endblock %} </body> </html>
In this template, there are two blocks: one for the title and one for the content. The {% block %}
tag allows child templates to override specific sections of the base template.
Now, we can rewrite the index.html
file to extend the base.html
file. We can remove all of the basic HTML structure, like the head
and title
tags from the index.html
file, and replace it with the extends
tag.
{% extends 'base.html' %} {% block title %}Welcome to Flask{% endblock %} {% block content %} {% if user.is_logged_in %} <p>Welcome back, {{ user.name }}!</p> {% else %} <p>Please log in to continue.</p> {% endif %} {% endblock %}
On the about page, we could also rewrite it as follows:
{% extends 'base.html' %} {% block title %}About Us{% endblock %} {% block content %} <p>This is the about page.</p> {% endblock %}
When we visit the homepage, we’ll see the “Welcome back, Joann!” message if the user is logged in. On the about page, we’ll see “This is the about page.”. The difference here is that both pages are cleaner and easier to maintain, without repeating code.
That’s how we can render HTML templates in Flask using Jinja. Jinja is a powerful templating engine that comes with helpful features and extensions, making it easier to build dynamic web applications in Python.
There’s still a lot more to explore, but I hope this article gives you a solid starting point to get up and running with Flask.
The post How to Render Templates in Flask appeared first on Hongkiat.
While building some plugins, I figured creating dynamic applications in WordPress Admin is much easier with React components compared to using PHP and jQuery like back in the old days. However, integrating React components with WordPress Admin can be a bit challenging, especially when it […]
WordpressWhile building some plugins, I figured creating dynamic applications in WordPress Admin is much easier with React components compared to using PHP and jQuery like back in the old days. However, integrating React components with WordPress Admin can be a bit challenging, especially when it comes to styling and accessibility. This led me to create Kubrick UI.
Kubrick UI is a React-based library offering pre-built, customizable components that seamlessly integrate with the WordPress admin area. It improves both visual consistency and accessibility, making it easier for you to create clean, dynamic interfaces in WordPress Admin, such as creating a Custom Settings Pages.
Before we go further, I’d assume that you’re already familiar with how WordPress plugins work. You’re also familiar with JavaScript, React, and how to install Node.js packages with NPM as we won’t dig into these fundamentals in this tutorial. Otherwise, check out our articles below to help you get up to speed.
If you’re ready, we can now get started with our tutorial on how to create our WordPress Settings page.
First, we are going to create and organize the files required:
. |-- package.json |-- settings-page.php |-- src |-- index.js |-- App.js |-- styles.scss
We have the src
directory containing the source files, stylesheet, and JavaScript files, which will contain the app components and the styles. We also created settings-page.php
, which contains the WordPress plugin header so that we can load our code as a plugin in WordPress. Lastly, we have package.json
so we can install some NPM packages.
Next, we are going to install the @syntatis/kubrick
package for our UI components, as well as a few other packages that it depends on and some that we need to build the page: @wordpress/api-fetch
, @wordpress/dom-ready
, react
, and react-dom
.
npm i @syntatis/kubrick @wordpress/api-fetch @wordpress/dom-ready react react-dom
And the @wordpress/scripts
package as a development dependency, to allow us to compile the source files easily.
npm i @wordpress/scripts -D
Within the package.json
, we add a couple of custom scripts, as follows:
{ "scripts": { "build": "wp-scripts build", "start": "wp-scripts start" } }
The build
script will allow us to compile the files within the src
directory into files that we will load on the Settings Page. During development, we are going to run the start
script.
npm run start
After running the script, you should find the compiled files in the build
directory:
. |-- index.asset.php |-- index.css |-- index.js
There are several steps we are going to do and tie together to create the Settings Page.
First, we are going to update our settings-page.php
file to register our settings page in WordPress, and register the settings and the options for the page.
add_action('admin_menu', 'add_submenu'); function add_submenu() { add_submenu_page( 'options-general.php', // Parent slug. 'Kubrick Settings', 'Kubrick', 'manage_options', 'kubrick-setting', function () { ?> <div class="wrap"> <h1><?php echo esc_html(get_admin_page_title()); ?></h1> <div id="kubrick-settings"></div> <noscript> <p> <?php esc_html_e('This settings page requires JavaScript to be enabled in your browser. Please enable JavaScript and reload the page.', 'settings-page-example'); ?> </p> </noscript> </div> <?php }, ); } function register_settings() { register_setting( 'kubrick_option_group', 'admin_footer_text', [ 'type' => 'string', 'sanitize_callback' => 'sanitize_text_field', 'default' => 'footer text', 'show_in_rest' => true, ] ); } add_action('admin_init', 'register_settings'); add_action('rest_api_init', 'register_settings');
Here, we are adding a submenu page under the Settings menu in WordPress Admin. We also register the settings and options for the page. The register_setting
function is used to register the setting, and the show_in_rest
parameter is set to true
, which is important to make the setting and the option available in the WordPress /wp/v2/settings
REST API.
The next thing we are going to do is enqueue the stylesheet and JavaScript files that we have compiled in the build
directory. We are going to do this by adding an action hook to the admin_enqueue_scripts
action.
add_action('admin_enqueue_scripts', function () { $assets = include plugin_dir_path(__FILE__) . 'build/index.asset.php'; wp_enqueue_script( 'kubrick-setting', plugin_dir_url(__FILE__) . 'build/index.js', $assets['dependencies'], $assets['version'], true ); wp_enqueue_style( 'kubrick-setting', plugin_dir_url(__FILE__) . 'build/index.css', [], $assets['version'] ); });
If you load WordPress Admin, you should now see the new submenu under Settings. On the page of this submenu, we render a div
with the ID root
where we are going to render our React application.
At this point, there’s nothing to see on the page just yet. We will need to create a React component and render it on the page.
To create the React application, we first add the App function component in our App.js
file. We also import the index.css
from the @syntatis/kubrick
package within this file to apply the basic styles to some of the components.
import '@syntatis/kubrick/dist/index.css'; export const App = () => { return <p>Hello World from App</p>; };
In the index.js
, we load and render our App
component with React.
import domReady from '@wordpress/dom-ready'; import { createRoot } from 'react-dom/client'; import { App } from './App'; domReady( () => { const container = document.querySelector( '#root' ); if ( container ) { createRoot( container ).render( <App /> ); } } );
In this example, we’d like to add a text input on the Settings Page which will allow the user to set the text that will be displayed in the admin footer.
Kubrick UI currently offers around 18 components. To create the example mentioned, we can use the TextField
component to create an input field for the “Admin Footer Text” setting, allowing users to modify the text displayed in the WordPress admin footer. The Button component is used to submit the form and save the settings. We also use the Notice
component to show feedback to the user, such as when the settings are successfully saved or if an error occurs during the process. The code fetches the current settings on page load and updates them via an API call when the form is submitted.
import { useEffect, useState } from 'react'; import apiFetch from '@wordpress/api-fetch'; import { Button, TextField, Notice } from '@syntatis/kubrick'; import '@syntatis/kubrick/dist/index.css'; export const App = () => { const [status, setStatus] = useState(null); const [statusMessage, setStatusMessage] = useState(null); const [values, setValues] = useState(); // Load the initial settings when the component mounts. useEffect(() => { apiFetch({ path: '/wp/v2/settings' }) .then((data) => { setValues({ admin_footer_text: data?.admin_footer_text, }); }) .catch((error) => { setStatus('error'); setStatusMessage('An error occurred. Please try to reload the page.'); console.error(error); }); }, []); // Handle the form submission. const handleSubmit = (e) => { e.preventDefault(); const data = new FormData(e.target); apiFetch({ path: '/wp/v2/settings', method: 'POST', data: { admin_footer_text: data.get('admin_footer_text'), }, }) .then((data) => { setStatus('success'); setStatusMessage('Settings saved.'); setValues(data); }) .catch((error) => { setStatus('error'); setStatusMessage('An error occurred. Please try again.'); console.error(error); }); }; if (!values) { return; } return ( <> {status && <Notice level={status} isDismissable onDismiss={() => setStatus(null)}>{statusMessage}</Notice>} <form method="POST" onSubmit={handleSubmit}> <table className="form-table" role="presentation"> <tbody> <tr> <th scope="row"> <label htmlFor="admin-footer-text" id="admin-footer-text-label" > Admin Footer Text </label> </th> <td> <TextField aria-labelledby="admin-footer-text-label" id="admin-footer-text" className="regular-text" defaultValue={values?.admin_footer_text} name="admin_footer_text" description="This text will be displayed in the admin footer." /> </td> </tr> </tbody> </table> <Button type="submit">Save Settings</Button> </form> </> ); }; export default App;
We’ve just created a simple custom settings page in WordPress using React components and the Kubrick UI library.
Our Settings Page here is not perfect, and there are still many things we could improve. For example, we could add more components to make the page more accessible or add more features to make the page more user-friendly. We could also add more error handling or add more feedback to the user when the settings are saved. Since we’re working with React, you can also make the page more interactive and visually appealing.
I hope this tutorial helps you get started with creating a custom settings page in WordPress using React components. You can find the source code for this tutorial on GitHub, and feel free to use it as a starting point for your own projects.
The post How to Create a WordPress Settings Page with React appeared first on Hongkiat.
It’s Here! How To Measure UX & Design Impact, With Vitaly Friedman It’s Here! How To Measure UX & Design Impact, With Vitaly Friedman Vitaly Friedman 2024-10-15T14:00:00+00:00 2025-03-04T21:34:45+00:00 Finally! After so many years, we’re very happy to launch “How To Measure UX and Design Impact”, […]
Ux
2024-10-15T14:00:00+00:00
2025-03-04T21:34:45+00:00
Finally! After so many years, we’re very happy to launch “How To Measure UX and Design Impact”, our new practical guide for designers and managers on how to set up and track design success in your company — with UX scorecards, UX metrics, the entire workflow and Design KPI trees. Neatly put together by yours truly, Vitaly Friedman. Jump to details.
$ 495.00 $ 799.00
Get Video + UX Training
25 video lessons (8h) + Live UX Training.
100 days money-back-guarantee.
25 video lessons (8h). Updated yearly.
Also available as a UX Bundle with 2 video courses.
In many companies, designers are perceived as disruptors, rather than enablers. Designers challenge established ways of working. They ask a lot of questions — much needed ones but also uncomfortable ones. They focus “too much” on user needs, pushing revenue projections back, often with long-winded commitment to testing and research and planning and scoping.
Almost every department in almost every company has their own clearly defined objectives, metrics and KPIs. In fact, most departments — from finance to marketing to HR to sales — are remarkably good at visualizing their impact and making it visible throughout the entire organization.
But as designers, we rarely have a set of established Design KPIs that we regularly report to senior management. We don’t have a clear definition of design success. And we rarely measure the impact of our work once it’s launched. So it’s not surprising that moste parts of the business barely know what we actually do all day long.
Business wants results. It also wants to do more of what has worked in the past. But it doesn’t want to be disrupted — it wants to disrupt. It wants to reduce time to market and minimize expenses; increase revenue and existing business, find new markets. This requires fast delivery and good execution.
And that’s what we are often supposed to be — good “executors”. Or to put differently, “pixel pushers”.
Over years, I’ve been searching for a way to change that. This brought me to Design KPIs and UX scorecards, and a workflow to translate business goals into actionable and measurable design initiatives. I had to find a way to explain, visualize and track that incredible impact that designers have on all parts of business — from revenue to loyalty to support to delivery.
The results of that journey are now public in our new video course: “How To Measure UX and Design Impact” — a practical guide for designers, researchers and UX leads to measure and visualize UX impact on business.
The course dives deep into establishing team-specific design KPIs, how to track them effectively, how to set up ownership and integrate metrics in design process. You’ll discover how to translate ambiguous objectives into practical design goals, and how to measure design systems and UX research.
Also, we’ll make sense of OKRs, Top Task Analysis, SUS, UMUX-Lite, UEQ, TPI, KPI trees, feedback scoring, gap analysis, and Kano model — and what UX research methods to choose to get better results. Jump to the table of contents or get your early-bird.
A practical guide to UX metrics and Design KPIs
8h-video course + live UX training. Free preview.
25 chapters, 8 hours, with practical examples, exercises, and everything you need to master the art of measuring UX and design impact. Don’t worry, even if it might seem overwhelming at first, we’ll explore things slowly and thoroughly. Taking 1–2 sessions per week is a perfectly good goal to aim for.
So, how do we measure UX? Well, let’s find out! Meet a friendly welcome message to the video course, outlining all the fine details we’ll be going through: design impact, business metrics, design metrics, surveys, target times and states, measuring UX in B2B and enterprises, design KPI trees, Kano model, event storming, choosing metrics, reporting design success — and how to measure design systems and UX research efforts.
Keywords:
Design impact, UX metrics, business goals, articulating design value, real-world examples, showcasing impact, evidence-driven design.
In this segment, we’ll explore how and where we, as UX designers, make an impact within organizations. We’ll explore where we fit in the company structure, how to build strong relationships with colleagues, and how to communicate design value in business terms.
Keywords:
Design impact, design ROI, orgcharts, stakeholder engagement, business language vs. UX language, Double Diamond vs. Reverse Double Diamond, risk mitigation.
We’ll explore the key business terms and concepts related to measuring business performance. We’ll dive into business strategy and tactics, and unpack the components of OKRs (Objectives and Key Results), KPIs, SMART goals, and metrics.
Keywords:
OKRs, objectives, key results, initiatives, SMART goals, measurable goals, time-bound metrics, goal-setting framework, business objectives.
Businesses often speak of leading and lagging indicators — predictive and retrospective measures of success. Let’s explore what they are and how they are different — and how we can use them to understand the immediate and long-term impact of our UX work.
Keywords:
Leading vs. lagging indicators, cause-and-effect relationship, backwards-looking and forward-looking indicators, signals for future success.
We dive into the world of business metrics, from Monthly Active Users (MAU) to Monthly Recurring Revenue (MRR) to Customer Lifetime Value (CLV), and many other metrics that often find their way to dashboards of senior management.
Also, almost every business measures NPS. Yet NPS has many limitations, requires a large sample size to be statistically reliable, and what people say and what people do are often very different things. Let’s see what we as designers can do with NPS, and how it relates to our UX work.
Keywords:
Business metrics, MAU, MRR, ARR, CLV, ACV, Net Promoter Score, customer loyalty.
We’ll explore the broader context of business metrics, including revenue-related measures like Monthly Recurring Revenue (MRR) and Annual Recurring Revenue (ARR), Customer Lifetime Value (CLV), and churn rate.
We’ll also dive into Customer Satisfaction Score (CSAT) and Customer Effort Score (CES). We’ll discuss how these metrics are calculated, their importance in measuring customer experience, and how they complement other well-known (but not necessarily helpful) business metrics like NPS.
Keywords:
Customer Lifetime Value (CLV), churn rate, Customer Satisfaction Score (CSAT), Customer Effort Score (CES), Net Promoter Score (NPS), Monthly Recurring Revenue (MRR), Annual Recurring Revenue (ARR).
If you are looking for a simple alternative to NPS, feedback scoring and gap analysis might be a neat little helper. It transforms qualitative user feedback into quantifiable data, allowing us to track UX improvements over time. Unlike NPS, which focuses on future behavior, feedback scoring looks at past actions and current perceptions.
Keywords:
Feedback scoring, gap analysis, qualitative feedback, quantitative data.
We’ll explore the landscape of established and reliable design metrics for tracking and capturing UX in digital products. From task success rate and time on task to System Usability Scale (SUS) to Standardized User Experience Percentile Rank Questionnaire (SUPR-Q) to Accessible Usability Scale (AUS), with an overview of when and how to use each, the drawbacks, and things to keep in mind.
Keywords:
UX metrics, KPIs, task success rate, time on task, error rates, error recovery, SUS, SUPR-Q.
We’ll continue with slightly shorter alternatives to SUS and SUPR-Q that could be used in a quick email survey or an in-app prompt — UMUX-Lite and Single Ease Question (SEQ). We’ll also explore the “big behemoths” of UX measurements — User Experience Questionnaire (UEQ), Google’s HEART framework, and custom UX measurement surveys — and how to bring key metrics together in one simple UX scorecard tailored to your product’s unique needs.
Keywords:
UX metrics, UMUX-Lite, Single Ease Question (SEQ), User Experience Questionnaire (UEQ), HEART framework, UEQ, UX scorecards.
The most impactful way to measure UX is to study how successful users are in completing their tasks in their common customer journeys. With top tasks analysis, we focus on what matters, and explore task success rates and time on task. We need to identify representative tasks and bring 15–18 users in for testing. Let’s dive into how it all works and some of the important gotchas and takeaways to consider.
Keywords:
Top task analysis, UX metrics, task success rate, time on task, qualitative testing, 80% success, statistical reliability, baseline testing.
Designing good surveys is hard! We need to be careful on how we shape our questions to avoid biases, how to find the right segment of audience and large enough sample size, how to provide high confidence levels and low margins of errors. In this chapter, we review best practices and a cheat sheet for better survey design — along with do’s and don’ts on question types, rating scales, and survey pre-testing.
Keywords:
Survey design, question types, rating scales, survey length, pre-testing, response rates, statistical significance, sample quality, mean vs. median scores.
Best measurements come from testing with actual users. But what if you don’t have access to any users? Perhaps because of NDA, IP concerns, lack of clearance, poor availability, and high costs of customers and just lack of users? Let’s explore how we can find a way around such restrictive environments, how to engage with stakeholders, and how we can measure efficiency, failures — and set up UX KPI programs.
Keywords:
B2B, enterprise UX, limited access to users, compliance, legacy systems, compliance, desk research, stakeholder engagement, testing proxies, employee’s UX.
To visualize design impact, we need to connect high-level business objectives with specific design initiatives. To do that, we can build up and present Design KPI trees. From the bottom up, the tree captures user needs, pain points, and insights from research, which inform design initiatives. For each, we define UX metrics to track the impact of these initiatives, and they roll up to higher-level design and business KPIs. Let’s explore how it all works in action and how you can use it in your work.
Keywords:
User needs, UX metrics, KPI trees, sub-trees, design initiatives, setting up metrics, measuring and reporting design impact, design workflow, UX metrics graphs, UX planes.
How do we choose the right metrics? Well, we don’t start with metrics. We start by identifying most critical user needs and assess the impact of meeting user needs well. To do that, we apply event storming by mapping critical user’s success moments as they interact with a digital product. Our job, then, is to maximize success, remove frustrations, and pave a clear path towards a successful outcome — with event storming.
Keywords:
UX mapping, customer journey maps, service blueprints, event storming, stakeholder alignment, collaborative mapping, UX lanes, critical events, user needs vs. business goals.
Once we have a business objective in front of us, we need to choose design initiatives that are most likely to drive the impact that we need to enable with our UX work. To test how effective our design ideas are, we can map them against a Kano model und run a concept testing survey. It gives us a user’s sentiment that we then need to weigh against business priorities. Let’s see how to do just that.
Keywords:
Feature prioritization, threshold attributes, performance attributes, excitement attributes, user’s sentiment, mapping design ideas, boosting user’s satisfaction.
How do we design a KPI tree from scratch? We start by running a collaborative event storming to identify key success moments. Then we prioritize key events and explore how we can amplify and streamline them. Then we ideate and come up with design initiatives. These initiatives are stress tested in an impact-effort matrix for viability and impact. Eventually, we define and assign metrics and KPIs, and pull them together in a KPI tree. Here’s how it works from start till the end.
Keywords:
Uncovering user needs, impact-effort matrix, concept testing, event storming, stakeholder collaboration, traversing the KPI tree.
Should we rely on established UX metrics such as SUS, UMUX-Lite, and SUPR-Q, or should we define custom metrics tailored to product and user needs? We need to find a balance between the two. It depends on what we want to measure, what we actually can measure, and whether we want to track local impact for a specific change or global impact for the entire customer journey. Let’s figure out how to define and establish metrics that actually will help us track our UX success.
Keywords:
Local vs. global KPIs, time spans, percentage vs. absolute values, A/B testing, mapping between metrics and KPIs, task breakdown, UX lanes, naming design KPIs.
Different contexts will require different design KPIs. In this chapter, we explore a diverse set of UX metrics related to search quality (quality of search for top 100 search queries), form design (error frequency, accuracy), e-commerce (time to final price), subscription-based services (time to tier boundaries), customer support (service desk inquiries) and many others. This should give you a good starting point to build upon for your own product and user needs.
Keywords:
Time to first success, search results quality, form error recovery, password recovery rate, accessibility coverage, time to tier boundaries, service desk inquiries, fake email frequency, early drop-off rate, carbon emissions per page view, presets and templates usage, default settings adoption, design system health.
Establishing UX metrics doesn’t happen over night. You need to discuss and decide what you want to measure and how often it should happen. But also how to integrate metrics, evaluate data, and report findings. And how to embed them into an existing design workflow. For that, you will need time — and green lights from your stakeholders and managers. To achieve that, we need to tap into the uncharted waters of UX strategy. Let’s see what it involves for us and how to make progress there.
Keywords:
Stakeholder engagement, UX maturity, governance, risk mitigation, integration, ownership, accountability, viability.
Once you’ve established UX metrics, you will need to report them repeatedly to the senior management. How exactly would you do that? In this chapter, we explore the process of selecting representative tasks, recruiting participants, facilitating testing sessions, and analyzing the resulting data to create a compelling report and presentation that will highlight the value of your UX efforts to stakeholders.
Keywords:
Data analysis, reporting, facilitation, observation notes, video clips, guidelines and recommendations, definition of design success, targets, alignment, and stakeholder’s buy-in.
To show the impact of our design work, we need to track UX snapshots. Basically, it’s four states, mapped against touch points in a customer journey: baseline (threshold not to cross), current state (how we are currently doing), target state (objective we are aiming for), and industry benchmark (to stay competitive). Let’s see how it would work in an actual project.
Keywords:
Competitive benchmarking, baseline measurement, local and global design KPIs, cross-teams metrics, setting realistic goals.
How do we measure the health of a design system? Surely it’s not just a roll-out speed for newly designed UI components or flows. Most teams track productivity and coverage, but we can also go beyond that by measuring relative adoption, efficiency gains (time saved, faster time-to-market, satisfaction score, and product quality). But the best metric is how early designers involve the design system in a conversation during their design work.
Keywords:
Component coverage, decision trees, adoption, efficiency, time to market, user satisfaction, usage analytics, design system ROI, relative adoption.
Research insights often end up gaining dust in PDF reports stored on remote fringes of Sharepoint. To track the impact of UX research, we need to track outcomes and research-specific metrics. The way to do that is to track UX research impact for UX and business, through organisational learning and engagement, through make-up of research efforts and their reach. And most importantly: amplifying research where we expect the most significant impact. Let’s see what it involves.
Keywords:
Outcome metrics, organizational influence, research-specific metrics, research references, study observers, research formalization, tracking research-initiated product changes.
So you’ve made it so far! Now, how do you get your UX metrics initiative off the ground? By following small steps heading in the right direction. Small commitments, pilot projects, and design guilds will support and enable your efforts. We just need to define realistic goals and turn UX metrics in a culture of measurement, or simply a way of working. Let’s see how we can do just that.
Keywords:
Pilot projects, UX integration, resource assessment, evidence-driven design, establishing a baseline, culture of measurement.
Let’s wrap up our journey into UX metrics and Design KPIs and reflect what we have learned. What remains is the first next step: and that would be starting where you are and growing incrementally, by continuously visualizing and explaining your UX impact — however limited it might be — to your stakeholders. This is the last chapter of the course, but the first chapter of your incredible journey that’s ahead of you.
Keywords:
Stakeholder engagement, incremental growth, risk mitigation, user satisfaction, business success.
This course is tailored for advanced UX practitioners, design leaders, product managers, and UX researchers who are looking for a practical guide to define, establish and track design KPIs, translate business goals into actionable design tasks, and connect business needs with user needs.
By the end of the video course, you’ll have a packed toolbox of practical techniques and strategies on how to define, establish, sell, and measure design KPIs from start to finish — and how to make sure that your design work is always on the right trajectory. You’ll learn:
Producing a video course takes quite a bit of time, and we couldn’t pull it off without the support of our wonderful community. So thank you from the bottom of our hearts! We hope you’ll find the course useful for your work. Happy watching, everyone! 🎉🥳
$ 495.00 $ 799.00
Get Video + UX Training
25 video lessons (8h) + Live UX Training.
100 days money-back-guarantee.
25 video lessons (8h). Updated yearly.
Also available as a UX Bundle with 2 video courses.
How A Bottom-Up Design Approach Enhances Site Accessibility How A Bottom-Up Design Approach Enhances Site Accessibility Eleanor Hecks 2024-10-04T09:00:00+00:00 2025-03-04T21:34:45+00:00 Accessibility is key in modern web design. A site that doesn’t consider how its user experience may differ for various audiences — especially those with […]
Ux
2024-10-04T09:00:00+00:00
2025-03-04T21:34:45+00:00
Accessibility is key in modern web design. A site that doesn’t consider how its user experience may differ for various audiences — especially those with disabilities — will fail to engage and serve everyone equally. One of the best ways to prevent this is to approach your site from a bottom-up perspective.
Conventional, top-down design approaches start with the big picture before breaking these goals and concepts into smaller details. Bottom-up philosophies, by contrast, consider the minute details first, eventually achieving the broader goal piece by piece.
This alternative way of thinking is important for accessibility in general because it reflects how neurodivergent people commonly think. While non-autistic people tend to think from a top-down perspective, those with autism often employ a bottom-up way of thinking.
Of course, there is considerable variation, and researchers have identified at least three specialist thinking types within the autism spectrum:
Still, research shows that people with autism and ADHD show a bias toward bottom-up thinking rather than the top-down approach you often see in neurotypical users. Consequently, a top-down strategy means you may miss details your audience may notice, and your site may not feel easily usable for all users.
As a real-world example, consider the task of writing an essay. Many students are instructed to start an essay assignment by thinking about the main point they want to convey and then create an outline with points that support the main argument. This is top-down thinking — starting with the big picture of the topic and then gradually breaking down the topic into points and then later into words that articulate these points.
In contrast, someone who uses a bottom-up thinking approach might start an essay with no outline but rather just by freely jotting down every idea that comes to mind as it comes to mind — perhaps starting with one particular idea or example that the writer finds interesting and wants to explore further and branching off from there. Then, once all the ideas have been written out, the writer goes back to group related ideas together and arrange them into a logical outline. This writer starts with the small details of the essay and then works these details into the big picture of the final form.
In web design, in particular, a bottom-up approach means starting with the specifics of the user experience instead of the desired effect. You may determine a readable layout for a single blog post, then ask how that page relates to others and slowly build on these decisions until you have several well-organized website categories.
You may even get more granular. Say you start your site design by placing a menu at the bottom of a mobile site to make it easier to tap with one hand, improving ease of use. Then, you build a drop-down menu around that choice — placing the most popular or needed options at the bottom instead of the top for easy tapping. From there, you may have to rethink larger-scale layouts to work around those interactive elements being lower on the screen, slowly addressing larger categories until you have a finished site design.
In either case, the idea of bottom-up design is to begin with the most specific problems someone might have. You then address them in sequence instead of determining the big picture first.
While neither bottom-up nor top-down approaches dominate the industry, some web engineers prefer the bottom-up approach due to the various accessibility benefits this process provides. This strategy has several accessibility benefits.
The biggest benefit of bottom-up methods is that they prioritize the user’s needs.
Top-down approaches seem organized, but they often result in a site that reflects the designer’s choices and beliefs more than it serves your audience.
“
Consider some of the complaints that social media users have made over the years related to usability and accessibility for the everyday user. For example, many users complain that their Facebook feed will randomly refresh as they scroll for the sake of providing users with the most up-to-date content. However, the feature makes it virtually impossible to get back to a post a user viewed that they didn’t think to save. Likewise, TikTok’s watch history feature has come and gone over the years and still today is difficult for many users to find without viewing an outside tutorial on the subject.
This is a common problem: 95.9% of the largest one million homepages have Web Content Accessibility Guidelines (WCAG) errors. While a bottom-up alternative doesn’t mean you won’t make any mistakes, it may make them less likely, as bottom-up thinking often improves your awareness of new stimuli so you can catch things you’d otherwise overlook. It’s easier to meet user’s needs when you build your entire site around their experience instead of looking at UX as an afterthought.
Consider this example from Berkshire Hathaway, a multi-billion-dollar holding company. The overall design philosophy is understandable: It’s simple and direct, choosing to focus on information instead of fancy aesthetics that may not suit the company image. However, you could argue it loses itself in this big picture.
While it is simple, the lack of menus or color contrast and the small font make it harder to read and a little overwhelming. This confusion can counteract any accessibility benefits of its simplicity.
Alternatively, even a simple website redesign could include intuitive menus, additional contrast, and accessible font for easy navigation across the site.
The homepage for U.K. charity Scope offers a better example of web design centered around users’ needs. Concise, clear menus line the top of the page to aid quicker, easier navigation. The color scheme is simple enough to avoid confusion but provides enough contrast to make everything easy to read — something the sans-serif font further helps.
A top-down method also makes catering to a diverse audience difficult because you may need to shoehorn features into an existing design.
For example, say, a local government agency creates a website focused on providing information and services to a general audience of residents. The site originally featured high-resolution images, bright colors, and interactive charts.
However, they realize the images are not accessible to people navigating the site with screen readers, while multiple layers of submenus are difficult for keyboard-only users. Further, the bright colors make it hard for visually impaired users to read the site’s information.
The agency, realizing these accessibility concerns, adds captions to each image. However, the captions disrupt the originally intended visual aesthetics and user flow. Further, adjusting the bright colors would involve completely rethinking the site’s entire color palette. If these considerations had been made before the site was built, the site build could have specifically accommodated these elements while still creating an aesthetically pleasing and user-friendly result.
Alternatively, a site initially built with high contrast, a calm color scheme, clear typography, simple menus, and reduced imagery would make this site much more accessible to a wide user base from the get-go.
As a real-world example, consider the Awwwards website. There are plenty of menus to condense information and ease navigation without overloading the screen — a solid accessibility choice. However, there does not seem to be consistent thought in these menus’ placement or organization.
There are far too many menus; some are at the top while others are at the bottom, and a scrolling top bar adds further distractions. It seems like Awwwards may have added additional menus as an afterthought to improve navigation. This leads to inconsistencies and crowding because they did not begin with this thought.
In contrast,
Bottom-up alternatives address usability issues from the beginning, which results in a more functional, accessible website.
“
Redesigning a system to address a usability issue it didn’t originally make room for is challenging. It can lead to errors like broken links and other unintended consequences that may hinder access for other visitors. Some sites have even claimed to lose 90% of their traffic after a redesign. While bottom-up approaches won’t eliminate those possibilities, they make them less likely by centering everything around usage from the start.
The website for the Vasa Museum in Stockholm, Sweden, showcases a more cohesive approach to ensuring accessibility. Like Awwwards, it uses menus to aid navigation and organization, but there seems to be more forethought into these features. All menus are at the top, and there are fewer of them, resulting in less clutter and a faster way to find what you’re looking for. The overall design complements this by keeping things simple and neat so that the menus stand out.
Similarly, bottom-up design ensures you don’t miss as many accessibility concerns. When you start at the top, before determining what details fit within it, you may not consider all the factors that influence it. Beginning with the specifics instead makes it easier to spot and address problems you would’ve missed otherwise.
This awareness is particularly important for serving a diverse population. An estimated 16% of the global population — 1.6 billion people — have a significant disability. That means there’s a huge range of varying needs to account for, but most people lack firsthand experience living with these conditions. Consequently, it’s easy to miss things impacting others’ UX. You can overcome that knowledge gap by asking how everyone can use your site first.
As these benefits show, a bottom-up design philosophy can be helpful when building an accessible site. Still, top-down methods can be advantageous at times, too. Which is best depends on your situation.
Top-down approaches are a good way to ensure a consistent brand image, as you start with the overall idea and base future decisions on this concept. It also makes it easier to create a design hierarchy to facilitate decision-making within your team. When anyone has a question, they can turn to whoever is above them or refer to the broader goals. Such organization can also mean faster design processes.
Bottom-up methods, by contrast, are better when accessibility for a diverse audience is your main concern. It may be harder to keep everyone on the same overall design philosophy page, but it usually produces a more functional website. You can catch and solve problems early and pay great attention to detail. However, this can mean longer design cycles, which can incur extra costs.
It may come down to what your team is most comfortable with. People think and work differently, with some preferring a top-down approach while others find bottom-up more natural. Combining the two — starting with a top-down model before tackling updates from a bottom-up perspective — can be beneficial, too.
Should you decide a bottom-up design method is best for your goals, here are some ways you can embrace this philosophy.
One of the most important factors in bottom-up web design is to center everything around your users. As a result, your existing user base — whether from a separate part of your business or another site you run — is the perfect place to start.
Survey customers and web visitors about their experience on your sites and others. Ask what pain points they have and what features they’d appreciate. Any commonalities between responses deserve attention. You can also turn to WCAG standards for inspiration on accessible functionality, but first-hand user feedback should form the core of your mission.
Past sites and business projects can also reveal what specifics you should start with. Look for any accessibility gaps by combing through old customer feedback and update histories and using these sites yourself to find issues. Take note of any barriers or usability concerns to address in your next website.
Remember to document everything you find as you go. Up to 90% of organizations’ data is unstructured, making it difficult to analyze later. Reversing that trend by organizing your findings and recording your accessible design process will streamline future accessibility optimization efforts.
Keep in mind that a bottom-up strategy can be time-consuming. One of the reasons why top-down alternatives are popular is because they’re efficient. You can overcome this gap by splitting tasks between smaller teams. However, these groups must communicate frequently to ensure separate design considerations work as a cohesive whole.
A DevOps approach is helpful here. DevOps has helped 49% of its adopters achieve a faster time to market, and 61% report higher-quality deliverables. It also includes space for both detailed work and team-wide meetings to keep everyone on track. Such benefits ensure you can remain productive in a bottom-up strategy.
You can’t overstate the importance of accessible website design. By the same token, bottom-up philosophies are crucial in modern site-building. A detail-oriented approach makes it easier to serve a more diverse audience along several fronts. Making the most of this opportunity will both extend your reach to new niches and make the web a more equitable place.
The Web Accessibility Initiative’s WCAG standards are a good place to start. While these guidelines don’t necessarily describe how to apply a bottom-up approach, they do outline critical user needs and accessibility concerns your design should consider. The site also offers a free and comprehensive Digital Accessibility Foundations course for designers and developers.
Familiarizing yourself with these standards and best practices will make it easier to understand your audience before you begin designing your site. You can then build a more accessible platform from the ground up.
Additionally, the following are some valuable related reads that can act as inspiration in accessibility-centered and user-centric design.
By employing bottom-up thinking as well as resources like these in your design approach, you can create websites that not only meet current accessibility standards but actively encourage site use among users of all backgrounds and abilities.
Embracing Introversion In UX Embracing Introversion In UX Victor Yocco 2024-09-19T15:00:00+00:00 2025-03-04T21:34:45+00:00 I place myself firmly in the category of being an introvert when it comes to my role as a UX researcher. I love the process of planning and executing research. I have never […]
Ux
2024-09-19T15:00:00+00:00
2025-03-04T21:34:45+00:00
I place myself firmly in the category of being an introvert when it comes to my role as a UX researcher. I love the process of planning and executing research. I have never felt a need to be the loudest or most talkative person in a meeting. I contribute after I have developed something worth saying (or have a really bad joke worked up).
I also love interviews and usability testing, where I interact with users and engage in meaningful conversation. And then I am exhausted. I love speaking about the findings of research and sharing the spotlight with my colleagues during a presentation, and then I want to go to bed underneath the conference room table. I facilitate workshops with ease but have trouble mustering up the energy required to attend what often feels like mandatory post-workshop socializing.
In truth, I have sometimes felt introverted tendencies set me back at work, particularly as a consultant who needs to build relationships to keep the work flowing (in theory). An example would be getting called out by a manager in my junior days for not engaging in as many networking activities as I could have been with some of our clients. My defense of feeling overstimulated, overwhelmed, and uninterested in socializing fell on deaf ears.
I think we have grown in our understanding of introverts and what they need to be high performers, particularly since Susan Cain’s 2013 best-selling book Quiet: The Power of Introverts in a World That Can’t Stop Talking was released.
This article aims to celebrate the power of introversion in UX research and design. We’ll debunk common misconceptions, explore the unique strengths introverted researchers and designers bring to the table, and offer practical tips for thriving in a field that sometimes seems tailored for extroverts. My goal is to build on some of the work on UX and introversion that already exists. I’ve cited other articles where appropriate and shared the resources I’ve found on UX and introversion at the end of this article.
Introversion is not the same thing as being shy, just as extroversion isn’t the same thing as being brash. For simplicity and the sake of this article, I am going to use the following definitions provided by de Jongh & de la Croix:
“Extroverts get energy from interaction with others and like to share ideas with others to help develop their thinking, whereas introverts need to recharge on their own after much social contact and prefer to share ideas only when they are fully formed.”
There are many potential reasons one could have introvert or extrovert tendencies (McCulloch 2020), and these come on a scale where one might lean or introvert or extrovert depending on the occasion. Those who straddle the middle ground of introversion and extroversion are considered ambiverts.
As Jonathan Walter notes in a series of articles on introverts and UX, many UX professionals find themselves drawn to the field because of their introverted nature. Introversion, often misunderstood as shyness or social awkwardness, is simply a preference for internal reflection and processing. It’s about drawing energy from solitude and finding fulfillment in deep thought and meaningful connections.
As UX is clearly a space where introverts are drawn, there is already a decent amount of literature aimed at introverted UX practitioners. In writing this article, I wanted to differentiate from what is already out there, as well as extend.
I wanted to include some personal stories of introverts who aren’t myself and work in UX. To do this, I went to LinkedIn and asked people to send me personal anecdotes. My post, at least by my standards, was well received, with over 100 reactions and a dozen people sending me direct messages sharing anecdotes. I was even introduced to Tim Yeo, who has recently released a book on introverts in the workplace. I’ll be sharing some of the stories people shared with me over LinkedIn, where appropriate (and with their permission), throughout this article to help draw the connections to real life.
First, let’s talk a little about what we know about measuring if you (or others) are introverted, extroverted, or in between.
Understanding where you and your team members fall on the introversion-extroversion spectrum can be invaluable for tailoring your approach to work, collaboration, and personal development. Reinoud de Jongh and Anne de la Croix, two medical school professors, write that medical educators should know where they fall on the introversion — extroversion spectrum to deliver great teaching experiences. I’d extend this to UX practitioners, including UX managers, UX researchers, and designers. If we collaborate with others, we will benefit from knowing where we fall on this scale.
While there’s no single definitive test, here are a few simple and accessible tools that can offer insights:
There’s no right or wrong answer when it comes to introversion or extroversion. You might even find some folks are ambiverts who display different personalities in different settings. You can’t force your teammates to take these types of tests. But if you are able to get buy-in, it can be a fun activity to see who considers themselves more introverted or more extroverted. The goal is to understand your own preferences and tendencies and those of your colleagues so you can create a work environment that supports your well-being and maximizes your potential.
The idea that UX is an extrovert’s game couldn’t be further from the truth. As Jeremy Bird notes in his article on the strengths of introverts in design, it’s a field that demands a wide range of skills, including deep listening, empathy, observation, analysis, and creativity — all of which introverts excel at. With so much information already available from articles on UX and introversion noted in the biography below, I’m going to briefly highlight the commonly accepted strengths of introverts.
Introverts are often exceptional listeners. In user interviews, they give participants the space to fully express their thoughts and feelings, picking up on subtle cues and nuances that others might miss. This active listening leads to a deeper understanding of user needs and motivations, which is crucial for both research and design.
One practitioner shared their experience on LinkedIn:
“In a nutshell, being introverted gives a natural advantage in giving the user space to tell their story. I’m more likely to embrace pauses that others may feel are awkward, but this allows users to either double down on their point or think of another point to add (“lightbulb” moment).”
— Dominique S. Microsoft User Research via LinkedIn
Many introverts possess a high degree of empathy. They can easily put themselves in users’ shoes, feeling their frustrations and celebrating their successes. This empathy fuels user-centered design, ensuring that products and services are not only functional but also emotionally resonant.
Introverts are naturally observant. They notice details in user behavior, interface interactions, and environmental context that others might overlook.
Introverts often prefer to process information internally, engaging in deep, solitary reflection before sharing their insights. This leads to well-considered and insightful findings and well-crafted data-informed design.
Introverts tend to thrive in independent work environments. As Heather McCulloch notes, teachers should allow introverted students to work independently or in pairs. This way, they can focus deeply on research tasks, design problems, or data analysis without the distractions that come with constant collaboration.
Now that we’ve covered the commonly recognized strengths introverts bring to the table, let’s cover some common hurdles and explore effective strategies for overcoming them that empower introverts to thrive.
Being introverted can bring up some challenges when it comes to doing things that require a lot of social energy. However, many introverts in UX find ways to push beyond their natural tendencies to meet the demands of their profession. One UX practitioner shared their experience on LinkedIn:
“I’ve been extremely introverted all my life, but have always been able to proceed beyond my introverted boundaries because of a commitment to (perceived) duty. My passion for synergizing user needs, business needs, and the assorted bevy of constraints that arise helps me downplay and overlook any challenges arising from my tendency to be withdrawn.”
— Darren H. MS UXD via LinkedIn
Introverts might initially feel overwhelmed in networking situations or workshops due to the continual social interaction and the need to navigate unfamiliar environments and interact with new people, which can be particularly daunting for those who prefer solitude or small-group conversations.
Introverts may initially avoid presenting because they tend to prefer avoiding the spotlight. They may also worry about being judged or scrutinized by others.
For the introvert, you might not like this, but you need to get comfortable presenting, and the sooner you do, the better.
Solutions for researchers and designers:
I’ve personally found presenting in front of a large anonymous crowd to be less intimidating than smaller, intimate meetings where you might know a few people mixed in with a few strangers. In the end, I always remind myself I am supposed to be the expert on what I’ve been asked to present or that my job is to clearly state the outcome of our research to stakeholders hungry to see the relevance of their work. The audience wants to support you and see you succeed. I take confidence in that. I’m also exhausted after giving a presentation where I’ve left it all on the floor.
Now, let’s move on to topics beyond what I’ve found covered in existing articles on UX and introversion and cover workshop facilitation and managing group dynamics.
Introverts may find group dynamics challenging, as they often prefer solitary activities and may feel overwhelmed or drained by social interactions. In group settings, introverts may have difficulty asserting themselves, sharing their ideas, or actively participating in discussions. They may also feel uncomfortable being the center of attention or having to make decisions on the spot.
Additionally, introverts may struggle to build relationships with their peers in a group setting, as they may be hesitant to initiate conversations or join in on group activities. These challenges can make it difficult for introverts to fully engage and contribute in group settings, leading to feelings of isolation and exclusion.
One UX designer responding over LinkedIn eloquently shared their experience with communication challenges:
“Introversion can sometimes create challenges in communication, as my thoughtful nature can be misinterpreted as shyness or disinterest. To step out of my shell, I need to build trust with those around me before I can feel truly comfortable. However, I don’t see this as the worst thing in the world. Instead, I view it as an opportunity to identify areas where I need to improve and learn to advocate for myself more effectively in the future. In embracing both the strengths and challenges of being an introvert, I’ve found that my introverted nature not only enhances my work as a designer but also drives continuous personal and professional growth, ultimately leading to better outcomes for both myself and my team.”
— Arafa A. via LinkedIn
Managing group dynamics covers a broad number of situations UX professionals face on a daily basis. Let’s get a little more specific and focus on how introverted UXers can thrive as workshop facilitators.
If you’re an introverted UX professional who shies away from leading workshops, it’s time to reconsider. Here are some of the reasons introverts can be perfect workshop facilitators:
We’ve reviewed many of the challenges introverts might face in their daily work life. Let’s turn our attention to a more recent phenomenon, at least in terms of its widespread availability as an option for many UX professionals: remote work.
Increased telecommuting offers a unique opportunity for some introverts. Introverts, who often find comfort in solitude and derive energy from spending time alone, sometimes find the constant socialization and bustle of open-plan offices overwhelming and draining.
Remote work provides introverts with an opportunity to control their surroundings and create a workspace that promotes focus, productivity, and creativity. Remote work allows introverts to communicate and collaborate on their own terms. Introverts often prefer one-on-one interactions over large group meetings, and remote work makes it easier for them to engage in meaningful conversations with colleagues and clients.
While remote work has been a game-changer for many introverts, it is important to acknowledge that it is not without its challenges. Introverts may miss the camaraderie and social connections of an in-person workplace, and they may need to make a conscious effort to stay connected with colleagues and maintain a healthy work-life balance.
Introverts working remotely may need to develop strategies for self-advocacy and communication to ensure that their voices are heard and their contributions are valued in a virtual work environment.
Introverted remote employees can implement some of these strategies and tactics to enhance their productivity, reduce burnout, and maintain a positive work environment:
Implementing what we’ve covered in this section will help to reduce the likelihood of frustration from both remote working introverts and their colleagues.
We’ve covered a lot of ideas in this article. If you find yourself nodding along as an introvert or perhaps coming to the realization you or someone on your team is more introverted, this section and the next will end this article on a high note, introducing some actionable tips for introverted researchers and designers, and their managers and teammates, to create a more comfortable and successful working environment for introverts to thrive alongside their extroverted colleagues.
Everyone needs to engage in an appropriate amount of self-care to feel their best. For an introvert, this is often done in solitude, particularly after engaging in a day or week full of social interaction. Some tips that could apply to anyone but are of particular relevance to introverts include the following:
Introverts know themselves best and have spent a lifetime reflecting on who they are and what makes them wake up happy to go to work. As such, introverts may have a high awareness of their strengths. This allows an introvert to do the following:
Introverts might hesitate to speak up when the room is crowded with unknown future friends. However, anyone, introverted or not, needs to be their own best advocate when it comes to making colleagues and management aware of how to create the best workplace environment to thrive in:
It’s essential for introverts to advocate for their needs and communicate their preferred work styles to their colleagues and managers. One UX professional shared their experience on LinkedIn:
“I do my best work when I have time to think and prepare vs. on-demand thinking, speaking, & decision making. So, I ask for agendas, context, and pre-reads to help me make the most impact in meetings. When I shared this fact, it really helped my outgoing teammates, who never thought that others might operate differently than they do. I got feedback that this was a learning experience for them, and so I have continued to share this fact with new teammates to set expectations and advocate for myself since I find it to be an extrovert-centered business world.”
— Anonymous UXer on LinkedIn
Another LinkedIn UXer provided additional tactics for how they navigate communication styles and expectations, particularly in a fast-paced or extrovert-dominated environment.
“The longer I work with people in a creative capacity, the more I recognize the power of delay. Plenty of introverts are also high-achieving people pleasers (raises hand 🙋🏻). This has caused stress over the years when working with extroverts or verbal processors because there can be a perceived sense of urgency to every thought or ask.
[slowing things down] can look like using certain phrases to help slow down the implied urgency to allow me to more thoughtfully process the ask:
- “Ah, interesting! Could you say more about that?”
- “Can you clarify the ‘why’ behind this for me? I want to make sure I’ve got it right.”
- “How does this support our goals for < x project / user >?”
And if the ask comes through asynchronously via email or Slack, I ask myself the following:
- Was this sent during working hours?
- Am I the only one who can answer this question / address this issue?
- Can I provide a short response that lets the person know their message was seen and that it’s on my radar?”
— Kait L. UXer via LinkedIn
Introverts may not initially thrive when it comes to group dynamics. They might wish to observe the group before deeply engaging. They can find it difficult to assert themselves in a group setting and may feel overwhelmed by the constant need for social interaction.
Additionally, introverts may find it harder to contribute to discussions or be slower to form meaningful connections with others in a group. The extroverted nature of group dynamics can be draining for introverts, and they may require more time to recharge after being in a group setting.
Introverts often find creative ways to navigate the challenges of large group settings. One UX researcher shared their experience on LinkedIn:
“I have a monthly meeting with many employees (50+) to go over survey results. I realized it was super awkward for me just to wait as people joined the meeting. I tried to make small talk about upcoming weekend plans or what people had done over the weekend, but engagement was still pretty low, and I was not equipped enough to carry on conversations. I decided to fill the time with memes. I would search for user research memes and tie them into why user research is important. More people started coming to my meetings just to see the meme! As time went on, I became known as the meme person. While I can’t necessarily say if that’s a good thing — brand awareness is powerful! At least people know user research exists and that we’re fun — even if it all started from being awkward and introverted.”
— Anonymous LinkedIn UXer
I turned to Tim Yeo to provide some insight into how introverts can best prepare for moving up the career ladder. Tim provided some tactical advice focusing on teamwork and people skills:
“Practice your people skills. If you, as an individual, could do it all on your own, you would’ve probably done it already. If you can’t, then you need to work with people to bring your creation to life. It takes a team.”
Tim also shared the strategic reason behind the importance of leaders having excellent people skills:
“We also like to believe that higher management is always more sure, more right, and has all the answers. In my experience, the reality is almost the opposite. Problems get fuzzier, messier, and more complex the higher up the organization you go. Making decisions with incomplete, imperfect information is the norm. To operate successfully in this environment requires steering people to your worldview, and that takes people skills.”
You can find some additional information on ways for introverts (and extroverts) to gain people skills in some of the references listed at the end of this article.
Let’s move on and wrap up with some tips for those who are working alongside introverts.
If you are a manager of a team consisting of more than yourself, you likely have an introvert among your team. Tim Yeo states, “Research from Susan Cain’s book, Quiet, shows that 1⁄3 to 1⁄2 of our population identify as quiet or introverted.”
Therefore,
“If you work in a diverse team, it follows that 1/3 to 1/2 of your team are quiet. So if you don’t create a space for quiet ones to be heard, that means you are missing out on 1/3 to 1/2 of ideas.”
UX managers of teams, including introverts and extroverts, should engage in some of the following suggested practices to create an inclusive work environment where everyone feels valued, heard, and able to contribute effectively to the team’s success. UX managers can use these tips to foster a diverse and productive team dynamic that drives innovation and creativity.
As a bonus, if you’re an introverted UX Manager and you are managing a team composed of introverts and extroverts, remember to encourage a variety of communication channels for your team members. You might default to your preferred style of communication but recognize that different team members may prefer different communication channels.
Some extroverted team members might enjoy brainstorming in large meetings, and introverted team members might prefer to contribute their ideas through written channels such as email, chat, or discussion boards.
Encouraging a variety of communication channels ensures that all team members feel comfortable sharing their thoughts and ideas.
“
Tim Yeo provided this list of tactics for encouraging and engaging introverts in participating in discussion:
Now, let’s move on to focus on some tips for managing remote workers.
Managers and colleagues play a crucial role in creating a supportive and inclusive environment for introverted researchers and designers on dispersed teams. Here are some strategies to consider:
Managers and teams can implement these strategies to create a work environment that values and empowers introverted researchers and designers, enabling them to thrive and make significant contributions to the team’s success.
We create a more inclusive and productive environment when we understand and appreciate the unique needs and preferences of introverts. Whether you’re an introverted UXer navigating the challenges of remote work or a manager looking to foster a diverse and engaged team, the strategies and insights shared in this article can help you unlock the full potential of introverted talent.
“The superpower of introspection that comes with introversion has enabled me to reflect on my behaviours and engineer myself to become more of an omnivert — able to adapt to different situations.
Being self-aware and working hard to ladder up through increasingly more challenging experiences has taken me from an introvert who was too concerned to tweet to an active leader in the community, delivering seminars, speaking at an international conference and now running a mentorship program for hundreds of UX professionals across the globe.”
— Chris C. UX Master Certified, via LinkedIn
Introversion is not a weakness to be overcome but a valuable asset to be embraced. We build stronger teams, foster innovation, and ultimately deliver more meaningful and impactful user experiences when we create a culture that celebrates both introverted and extroverted strengths. The best solutions often emerge from a blend of diverse perspectives, including the quiet voices that deserve to be heard.
In closing, I’d like to use the words of Tim Yeo, who provides us with some inspiration and positive reinforcement of who we are as introverts:
“You are enough. The world may continue to favour the extrovert ideal, but pretending to be someone you are not will never feel right. Know that there is a different path to have impact at work where you don’t have to pretend to be someone you are not. That path comes from tiny habits, done well, accumulated over time.”
[You can learn more about tiny habits in Tim’s book The Quiet Achiever]