The 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 […]
UxCreating An Effective Multistep Form For Better User Experience Creating An Effective Multistep Form For Better User Experience Amejimaobari Ollornwi 2024-12-03T10:00:00+00:00 2025-03-04T21:34:45+00:00 For a multistep form, planning involves structuring questions logically across steps, grouping similar questions, and minimizing the number of steps and the amount […]
UxAs more desktop-based tools and mobile productivity apps shift to the cloud, Cloud-based Integrated Development Environments (IDEs) have become essential for web developers. These cloud IDEs allow you to code, debug, and collaborate directly from your browser, providing a seamless experience for building websites and […]
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. 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]
How To Build Custom Data Visualizations Using Luzmo Flex How To Build Custom Data Visualizations Using Luzmo Flex Paul Scanlon 2024-09-12T11:00:00+00:00 2025-03-04T21:34:45+00:00 This article is sponsored by Luzmo In this article, I’ll introduce you to Luzmo Flex, a new feature from the Luzmo team who […]
Ux
2024-09-12T11:00:00+00:00
2025-03-04T21:34:45+00:00
This article is sponsored by Luzmo
In this article, I’ll introduce you to Luzmo Flex, a new feature from the Luzmo team who have been working hard making developer tooling to flatten the on-ramp for analytics reporting and data visualization.
With Luzmo Flex, you can hook up a dataset and create beautifully crafted, fully customizable interactive charts that meet your reporting needs. They easily integrate and interact with other components of your web app, allowing you to move away from a traditional “dashboard” interface and build more bespoke data products.
While many charting libraries offer similar features, I often found it challenging to get the data into the right shape that the library needed. In this article, I’ll show you how you can build beautiful data visualizations using the Google Analytics API, and you won’t have to spend any time “massaging” the data!
Well, it’s two things, really. First of all, Luzmo is a low-code platform for embedded analytics. You can create datasets from just about anything, connect them to APIs like Google Analytics or your PostgreSQL database, or even upload static data in a .csv
file and start creating data visualizations with drag and drop.
Secondly, Luzmo Flex is their new React component that can be configured to create custom data visualizations. Everything from the way you query your data to the way you display it can be achieved through code using the LuzmoVizItemComponent.
What makes Luzmo Flex unique is that you can reuse the core functionalities of Luzmo’s low-code embedded analytics platform in your custom-coded components.
“
That means, besides creating ready-to-use datasets, you can set up functions like the following out-of-the-box:
By combining these off-the-shelf functions with flexibility through code, Luzmo Flex makes a great solution for building bespoke data products that go beyond the limits of a traditional dashboard interface. Below are a few examples of what that could look like.
A custom report builder that lets users search and filter a dataset and render it out using a number of different charts.
Enable powerful filtering using HTML Select inputs, which will update each chart shown on the page.
Or how about a sleep tracker hooked up to your phone to track all those important snoozes?
When building data-intensive applications, using something like Recharts, a well-known React charting library, you’ll likely need to reformat the data to fit the required shape. For instance, if I request the top 3 page views from the last seven days for my site, paulie.dev, I would have to use the Google Analytics API using the following query.
import dotenv from 'dotenv';
import { BetaAnalyticsDataClient } from '@google-analytics/data';
dotenv.config();
const credentials = JSON.parse(
Buffer.from(process.env.GOOGLE_APPLICATION_CREDENTIALS_BASE64, 'base64').toString('utf-8')
);
const analyticsDataClient = new BetaAnalyticsDataClient({
credentials,
});
const [{ rows }] = await analyticsDataClient.runReport({
property: `properties/${process.env.GA4_PROPERTY_ID}`,
dateRanges: [
{
startDate: '7daysAgo',
endDate: 'today',
},
],
dimensions: [
{
name: 'fullPageUrl',
},
{
name: 'pageTitle',
},
],
metrics: [
{
name: 'totalUsers',
},
],
limit: 3,
metricAggregations: ['MAXIMUM'],
});
The response would look something like this:
[
{
"dimensionValues": [
{
"value": "www.paulie.dev/",
"oneValue": "value"
},
{
"value": "Paul Scanlon | Home",
"oneValue": "value"
}
],
"metricValues": [
{
"value": "61",
"oneValue": "value"
}
]
},
{
"dimensionValues": [
{
"value": "www.paulie.dev/posts/2023/11/a-set-of-sign-in-with-google-buttons-made-with-tailwind/",
"oneValue": "value"
},
{
"value": "Paul Scanlon | A set of: "Sign In With Google" Buttons Made With Tailwind",
"oneValue": "value"
}
],
"metricValues": [
{
"value": "41",
"oneValue": "value"
}
]
},
{
"dimensionValues": [
{
"value": "www.paulie.dev/posts/2023/10/what-is-a-proxy-redirect/",
"oneValue": "value"
},
{
"value": "Paul Scanlon | What Is a Proxy Redirect?",
"oneValue": "value"
}
],
"metricValues": [
{
"value": "23",
"oneValue": "value"
}
]
}
]
To make that data work with Recharts, I’d need to reformat it so it conforms to the following data shape.
[
{
"name": "Paul Scanlon | Home",
"value": 61
},
{
"name": "Paul Scanlon | A set of: "Sign In With Google" Buttons Made With Tailwind",
"value": 41
},
{
"name": "Paul Scanlon | What Is a Proxy Redirect?",
"value": 23
}
]
To accomplish this, I’d need to use an Array.prototype.map()
to iterate over each item, destructure the relevant data and return a key-value pair for the name
and value
for each.
const data = response.rows.map((row) => {
const { dimensionValues, metricValues } = row;
const pageTitle = dimensionValues[1].value;
const totalUsers = parseInt(metricValues[0].value);
return {
name: pageTitle,
value: totalUsers,
};
});
And naturally, if you’re reformatting data this way in your application, you’d also want to write unit tests to ensure the data is always formatted correctly to avoid breaking your application… and all of this before you even get on to creating your charts!
With Luzmo Flex, all of this goes away, leaving you more time to focus on which data to display and how best to display it.
Typically, when building user interfaces that display data insights, your first job will be to figure out how to query the data source. This can take many forms, from RESTful API requests to direct database queries or sometimes reading from static files. Your next job will be figuring out when and how often these requests need to occur.
Each will likely inform your application’s architecture, and there’s no single solution to this. Your last job, as mentioned, will be wrangling the responses, reformatting the data, and displaying it in the UI.
Below, I’ll show you how to do this using Luzmo Flex by using a simple example product.
Here’s a screenshot of a simple data product I’ve built that displays three different charts for different reporting dimensions exposed by the Google Analytics API for page views for my site, paulie.dev, from the last seven days.
You can find all the code used in this article on the following link:
Before we get going, hop over to Luzmo and sign up for a free trial. You might also like to have a read of one of the getting started guides listed below. In this article, I’ll be using the Next.js starter.
To create data visualization, you’ll first need data! To achieve this using Luzmo, head over to the dashboard, select Datasets from the navigation, and select GA4 Google Analytics. Follow the steps shown in the UI to connect Luzmo with your Google Analytics account.
With the setup complete, you can now select which reporting dimensions to add to your dataset. To follow along with this article, select Custom selection.
Lastly, select the following using the search input. Device Category, Page Title, Date, and Total users, then click Import when you’re ready.
You now have all the data required to build the Google Analytics dashboard. You can access the dataset ID from the URL address bar in your browser. You’ll need this in a later step.
If you’ve followed along from either of the first two getting started guides, you’ll have your API Key, API Token, App server, and API host environment variables set up and saved in a .env
file.
If you’ve cloned one of the starter repositories, run the following to install the required dependencies.
npm install
Next, install the Luzmo React Embed dependency which exports the LuzmoVizItemComponent
.
npm install @luzmo/react-embed@latest
Now, find page.tsx
located in the src/app directory, and add your dataset id
as shown below.
Add the access
object from the destructured response and pass access.datasets[0].id
onto the LuzmoClientComponent
component using a prop named datasetId
.
// src/app/page.tsx
+ import dynamic from 'next/dynamic';
import Luzmo from '@luzmo/nodejs-sdk';
- import LuzmoClientComponent from './components/luzmo-client-component';
+ const LuzmoClientComponent = dynamic(() => import('./components/luzmo-client-component'), {
ssr: false,
});
const client = new Luzmo({
api_key: process.env.LUZMO_API_KEY!,
api_token: process.env.LUZMO_API_TOKEN!,
host: process.env.NEXT_PUBLIC_LUZMO_API_HOST!,
});
export default async function Home() {
const response = await client.create('authorization', {
type: 'embed',
username: 'user id',
name: 'first name last name',
email: 'name@email.com',
access: {
datasets: [
{
- id: '<dataset_id>',
+ id: '42b43db3-24b2-45e7-98c5-3fcdef20b1a3',
rights: 'use',
},
],
},
});
- const { id, token } = response;
+ const { id, token, access } = response;
- return <LuzmoClientComponent authKey={id} authToken={token} />;
+ return <LuzmoClientComponent authKey={id} authToken={token} datasetId={access.datasets[0].id} />;
}
And lastly, find luzmo-client-component.tsx
located in src/app/components. This is where you’ll be creating your charts.
The first chart you’ll create is a Donut chart that shows the various devices used by visitors to your site.
Add the following code to luzmo-client-component.tsx
component.
// src/app/component/luzmo-client-component.tsx
'use client';
+ import { LuzmoVizItemComponent } from '@luzmo/react-embed';
interface Props {
authKey: string;
authToken: string;
+ datasetId: string;
}
- export default function LuzmoClientComponent({ authKey, authToken}: Props) {
+ export default function LuzmoClientComponent({ authKey, authToken, datasetId }: Props) {
+ const date = new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000).toISOString(); // creates a date 7 days ago
console.log({ authKey, authToken });
return (
<section>
+ <div className='w-1/2 h-80'>
+ <LuzmoVizItemComponent
+ appServer={process.env.NEXT_PUBLIC_LUZMO_APP_SERVER}
+ apiHost={process.env.NEXT_PUBLIC_LUZMO_API_HOST}
+ authKey={authKey}
+ authToken={authToken}
+ type='donut-chart'
+ options={{
+ title: {
+ en: `Devices from last 7 days`,
+ },
+ display: {
+ title: true,
+ },
+ mode: 'donut',
+ legend: {
+ position: 'bottom',
+ },
+ }}
+ slots={[
+ {
+ name: 'measure',
+ content: [
+ {
+ label: {
+ en: 'Total users',
+ },
+ column: '<column id>', // Total users
+ set: datasetId,
+ type: 'numeric',
+ format: '.4f',
+ },
+ ],
+ },
+ {
+ name: 'category',
+ content: [
+ {
+ label: {
+ en: 'Device category',
+ },
+ column: '<column id>', // Device category
+ set: datasetId,
+ type: 'hierarchy',
+ },
+ ],
+ },
+ ]}
+ filters={[
+ {
+ condition: 'or',
+ filters: [
+ {
+ expression: '? >= ?',
+ parameters: [
+ {
+ column_id: '<column id>', // Date
+ dataset_id: datasetId,
+ },
+ date,
+ ],
+ },
+ ],
+ },
+ ]}
+ />
+ <div/>
</section>
);
}
There’s quite a lot going on in the above code snippet, and I will explain it all in due course, but first, I’ll need to cover a particularly tricky part of the configuration.
You’ll notice the filters parameters, measure, and category content all require a column id.
In the filters parameters, the key is named column_id
, and in the measure and category, the key is named column
. Both of these are actually the column IDs from the dataset. And here’s how you can find them.
Back in the Luzmo dashboard, click into your dataset and look for the “more dots” next to each column heading. From the menu, select Copy column id. Add each column ID to the keys in the configuration objects.
In my example, I’m using the Total users for the measure, the Device category for the category, and the Date for the filter.
If you’ve added the column IDs correctly, you should be able to see a rendered chart on your screen!
… and as promised, here’s a breakdown of the configuration.
The first part is fairly straightforward. appServer
and authKey
are the environment variables you saved to your .env
file, and authKey
and authToken
are destructured from the authorization request and passed into this component via props.
The type
prop determines which type of chart to render. In my example, I’m using donut-chart
, but you could choose from one of the many options available, area-chart
, bar-chart
, bubble-chart
, box-plot
, and many more. You can see all the available options in the Luzmo documentation under Chart docs.
<LuzmoVizItemComponent
appServer={process.env.NEXT_PUBLIC_LUZMO_APP_SERVER}
apiHost={process.env.NEXT_PUBLIC_LUZMO_API_HOST}
authKey={authKey}
authToken={authToken}
type='donut-chart'
The one thing I should point out is my use of Tailwind classes: w-1/2
(width: 50%) and h-80
(height: 20rem). The LuzmoVizItemComponent
ships with height 100%, so you’ll need to wrap the component with an element that has an actual height, or you won’t be able to see the chart on the page as it could be 100% of the height of an element with no height.
The options
object is where you can customize the appearance of your chart. It accepts many configuration options, among which:
title
for the chart that accepts a locale with corresponding text to display.display title
value to determine if the title is shown or not.mode
to determine if the chart is to be of type donut or pie chart.legend
option to determine where the legend can be positioned.All the available configuration options can be seen in the Donut chart documentation.
options={{
title: {
en: `Devices from last 7 days`,
},
display: {
title: true,
},
mode: 'donut',
legend: {
position: 'bottom',
},
}}
Slots are where you can configure which column from your dataset to use for the category and measure.
Slots can contain multiple measures, useful for displaying two columns of data per chart, but if more than two are used, one will become the measure.
Each measure contains a content array. The content array, among many other configurations, can include the following:
label
and locale,column
id from the dataset
,datasetId
,type
of data you’re displaying,format
for the data.The format used here is Python syntax for floating-point numbers; it’s similar to JavaScript’s .toFixed()
method, e.g number.toFixed(4)
.
The hierarchy
type is the Luzmo standard data type. Any text column is considered as an hierarchical data type.
You can read more in the Donut chart documentation about available configuration options for slots.
slots={[
{
name: 'measure',
content: [
{
label: {
en: 'Total users',
},
column: '<column id>', // Total users
set: datasetId,
type: 'numeric',
format: '.4f',
},
],
},
{
name: 'category',
content: [
{
label: {
en: 'Device category',
},
column: '<column id>', // Device category
set: datasetId,
type: 'hierarchy',
},
],
},
]}
The filters object is where you can apply conditions that will determine which data will be shown. In my example, I only want to show data from the last seven days. To accomplish this, I first create the date variable:
const date = new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000).toISOString();
This would produce an ISO date string, e.g., 2024-08-21T14:25:40.088Z
, which I can use with the filter. The filter uses Luzmo’s Filter Expressions, to determine if the date for each row of the data is greater than or equal to the date variable. You can read more about Filter Expressions in Luzmo’s Academy article.
filters={[
{
condition: 'or',
filters: [
{
expression: '? >= ?',
parameters: [
{
column_id: '<column id>', // Date
dataset_id: datasetId,
},
date,
],
},
],
},
]}
The second chart you’ll be creating is a Line chart that displays the number of page views on each date from the last seven days from folks who visit your site.
As with the Donut chart, the initial props are pretty much the same, but the type
has been changed to line-chart
.
<LuzmoVizItemComponent
appServer={process.env.NEXT_PUBLIC_LUZMO_APP_SERVER}
apiHost={process.env.NEXT_PUBLIC_LUZMO_API_HOST}
authKey={authKey}
authToken={authToken}
type='line-chart'
The options for the Line chart are as follows, and the mode
has been changed to line-chart
.
options={{
title: {
en: `Site visits from last 7 days`,
},
display: {
title: true,
},
mode: 'grouped',
}}
The slots object is almost the same as before with the Donut chart, but for the Line chart, I’m using the date
column from the dataset instead of the device category, and instead of category, I’m using the x-axis
slot type. To ensure I’m formatting the data correctly (by day), I’ve used level 5. You can read more about levels in the docs.
slots={[
{
name: 'measure',
content: [
{
label: {
en: 'Total users',
},
column: '<column id>', // Total users
set: datasetId,
type: 'numeric',
format: '.4f',
},
],
},
{
name: 'x-axis',
content: [
{
label: {
en: 'Date',
},
column: '<column id>', // Date
set: datasetId,
type: 'datetime',
level: 5,
},
],
},
]}
I’ve used the same filters as I used in the Donut chart.
The last chart you’ll be creating is a Bar chart that displays the number of page views for the top ten most viewed pages on your site.
As with the Donut and Line chart, the initial props are pretty much the same, but the type
has been changed to bar-chart
.
<LuzmoVizItemComponent
className='w-full h-80'
appServer={process.env.NEXT_PUBLIC_LUZMO_APP_SERVER}
apiHost={process.env.NEXT_PUBLIC_LUZMO_API_HOST}
authKey={authKey}
authToken={authToken}
type='bar-chart'
The options for the Bar chart are a little more involved. I’ve included some styling options for the border-radii
of the bars, limited the number of results to 10, and sorted the data by the highest page view count first using the sort
by
measure
and direction
options.
options={{
title: {
en: `Page views from last 7 days`,
},
display: {
title: true,
},
mode: 'grouped',
bars: {
roundedCorners: 5,
},
limit: {
number: 10,
},
sort: {
by: 'measure',
direction: 'desc',
},
}}
As with the Line chart, I’ve used an axis for one of the columns from the dataset. In this case, it’s the y-axis
which displays the page title.
slots={[
{
name: 'measure',
content: [
{
label: {
en: 'Total users',
},
column: '<column id>', // Total users
set: datasetId,
type: 'numeric',
format: '.4f',
},
],
},
{
name: 'y-axis',
content: [
{
label: {
en: 'Page title',
},
column: '<column id>', // Page title
set: datasetId,
type: 'hierarchy',
},
],
},
]}
I’ve used the same filters as I used in the Donut and Line chart.
As you can see, there are plenty of types of charts and customization options. Because this is just an “ordinary” React component, you can very easily make it configurable by an end user by allowing options to be set and unset using HTML input elements, checkbox, select, date, and so on.
But for me, the real power behind this is not having to mutate data!
This is particularly pertinent when displaying multiple charts with different reporting dimensions. Typically, this would require each to have their own utility function or reformatting method. That said, setting column IDs and dataset IDs is a little fiddly, but once you have the component hooked up to the dataset, you can configure and reconfigure as much as you like, all without having to rewrite data formatting functions.
If you’re interested in bringing data to life in your application and want to get it done without the usual headaches, book a free demo with the Luzmo team to learn more!
Flask is a lightweight and flexible micro-framework for Python that makes it easy to get started with web development. It’s designed to be simple and minimalistic, offering essential tools and features needed for building a web application, while allowing developers to have full control over […]
CodingFlask is a lightweight and flexible micro-framework for Python that makes it easy to get started with web development. It’s designed to be simple and minimalistic, offering essential tools and features needed for building a web application, while allowing developers to have full control over how to implement additional features.
It is a “micro-framework,” which means it doesn’t require specific tools or libraries. This gives developers the freedom to decide how they want to extend their application, making Flask a good choice for those who prefer flexibility and customization. If you’re coming from PHP, this could be an alternative to using other micro-frameworks like Slim. If you’re coming from Ruby, you might find Flask similar to Sinatra.
Let’s see how we can get started with Flask and build a simple web page.
First, we need to install Flask. We can do this by running:
pip install flask
Next, we need to create a Python file, for example, app.py
. To get started, we add the following code:
from flask import Flask app = Flask(__name__) @app.route('/') def home(): return "Hello Flask!"
The Flask
class is used to create an instance of the app. The @app.route('/')
decorator maps the homepage URL, /
, to the home
function, which returns the message “Hello Flask!”.
Now, run the app using the following command:
flask run --debug
When we visit http://127.0.0.1:5000/
in the web browser, we’ll see the message “Hello Flask!”.
In this case, we also run the app in debug mode, which automatically reloads the server when you make changes to the code. This is useful for development, as you can see the changes immediately without having to restart the server. Keep in mind that you’d want to disable debug mode when deploying your application to a production server.
One of the main features provided by Flask is routing. Routing is the process of mapping URLs to functions that handle requests. In the example above, we defined a route for the homepage using the @app.route('/')
decorator. This tells Flask to call the home
function when the user visits the homepage URL, /
.
We can define routes for other pages as well. For example, to create an About
page, we can add the following code:
@app.route('/about') def about(): return "This is the About page."
Now, if we load http://127.0.0.1:5000/about
, we’ll see the message “This is the About page.”.
Flask is a great choice for both beginners and experienced developers, especially when you want flexibility without the complexity of larger frameworks like Django.
In this article, we’ve covered the basics of how Flask works with some simple examples such as how to spin up the development server, and we learned a bit about routing in Flask to create static pages. In future articles, we’ll explore more advanced topics like rendering templates, working with forms, handling requests, and connecting to databases.
So stay tuned!
The post Getting Started with Flask appeared first on Hongkiat.
Ever wondered what would happen if your WordPress site suddenly disappeared? It’s a nightmare scenario, but one that can be easily avoided with the right backup solution in place. For anyone managing a WordPress site, whether it’s a personal blog or a full-scale business, having […]
WordpressEver wondered what would happen if your WordPress site suddenly disappeared?
It’s a nightmare scenario, but one that can be easily avoided with the right backup solution in place. For anyone managing a WordPress site, whether it’s a personal blog or a full-scale business, having a reliable backup is crucial.
This post highlights some of the best WordPress backup plugins available, focusing on their key features and how they can protect your site from unexpected data loss, security threats, and other digital disasters.
Let’s take a closer look at how these tools can help keep your WordPress site secure and your data intact.
BlogVault is a robust WordPress backup plugin that’s ideal for business-critical websites. It offers features like incremental backups, secure cloud storage, and one-click restore, making sure your site can bounce back quickly from any issues. With a strong track record of successful backups, BlogVault provides the reliability you need.
What sets BlogVault apart is its strong data security, with encrypted backups stored across multiple data centers. The plugin also makes it easy to create staging sites, so you can test changes before making them live. Its migration tool is another standout feature, allowing you to move your site to a new host with minimal effort.
BlogVault is perfect for businesses that need reliable backups, especially if downtime is not an option. It’s also great for developers who need staging environments or anyone who wants comprehensive backup and security for their WordPress site.
Previously known as BackupBuddy, Solid Backups has been around since 2010, helping WordPress users keep their sites safe. This plugin allows you to back up your entire site, including your database and files, with just a few clicks. You can choose to back up everything or only specific files and folders, and send these backups to secure locations like Amazon S3, Dropbox, or even your email.
Solid Backups also makes it easy to restore your site, whether you need to recover a single file or roll back your database. You can set up automatic backups on a schedule that works for you, so you don’t have to worry about losing any data.
Solid Backups is ideal for anyone who wants a dependable and user-friendly backup solution. It’s particularly useful if you manage multiple sites or prefer to set up backups once and let the plugin handle the rest.
UpdraftPlus is a widely trusted WordPress backup plugin, known for its reliability and ease of use. Whether you’re looking to create a complete backup of your website or just want to save specific parts like plugins, themes, or databases, UpdraftPlus makes it simple. You can choose to store your backups locally on your computer or in the cloud, with support for services like Dropbox, Google Drive, and Amazon S3.
This plugin offers both scheduled and on-demand backups, giving you the flexibility to secure your site whenever needed. While the free version covers essential features, upgrading to the premium version unlocks advanced options like incremental backups and seamless site migration. The straightforward setup ensures that even beginners can quickly get started with protecting their WordPress site.
UpdraftPlus is a good choice for anyone looking for a reliable backup plugin that’s easy to use. Whether you’re new to WordPress or have been using it for years, this plugin can help keep your site’s data safe, especially if you want to store backups in more than one place.
Following UpdraftPlus, Jetpack VaultPress Backups offers a robust solution for WordPress and WooCommerce sites, prioritizing data safety and easy recovery. Unlike many backup options, it provides real-time backups stored securely in the Jetpack Cloud, ensuring that every change on your site is instantly protected.
If your site encounters an issue, you can restore it swiftly with just a few clicks, even if your hosting service is experiencing downtime. With automated backups and a 30-day archive, Jetpack VaultPress Backups delivers peace of mind, making it a dependable choice for those who require continuous site protection.
This plugin is particularly well-suited for users who prioritize security and need a hands-off, automated backup solution, especially those managing online stores or frequently updated sites.
Visit Jetpack VaultPress Backups
As you explore backup solutions, BackWPup stands out as a straightforward yet powerful plugin for WordPress users. It simplifies the backup process, allowing you to easily secure your entire site, with storage options ranging from Dropbox to S3 and FTP. Additionally, BackWPup includes restore capabilities in its free version, making it a comprehensive choice for safeguarding your site.
Designed with ease of use in mind, BackWPup caters to both beginners and experienced users alike. You can schedule automatic backups and choose your preferred storage locations, ensuring that your site’s data remains safe and accessible whenever you need it.
BackWPup is great for anyone looking for a straightforward backup and restore plugin, whether you’re running a small blog or managing several sites.
The post 5 Best WordPress Backup Plugins for Data Security (2024) appeared first on Hongkiat.
The CSS @property is a powerful feature that brings more control and flexibility to custom properties, also known as CSS variables. It is introduced as part of the CSS Houdini project, which is designed to provide developers with deeper access to the browser’s rendering engine. […]
CodingThe CSS @property
is a powerful feature that brings more control and flexibility to custom properties, also known as CSS variables.
It is introduced as part of the CSS Houdini project, which is designed to provide developers with deeper access to the browser’s rendering engine. The @property
rule allows you to define custom properties with specific types, default values, and even the capability to animate CSS properties.
In this article, we’ll explore what the @property
rule is, why it’s useful, and how you can leverage it in your web projects.
@property
for?CSS custom properties, also known as CSS variables, have made styles more reusable. It allows you to define a value once and use it throughout your stylesheet.
However, one limitation has been the inability to specify a property’s type or set default values directly in CSS. This means any value can be assigned to a custom property, which can lead to unexpected results and make it harder to maintain your styles in some situations.
This is where the @property
rule comes in. It allows you to set a default value, provides a fallback value that will be used if the custom property is not explicitly set, enables custom property animation, and defines a type for a custom property.
This ensures that a variable can only accept a specific data type, such as a length, color, or number.
The type of the property is defined with the syntax
property. It accepts a string value defining the CSS type value, as follows:
Type | Description |
---|---|
<length> |
Any valid <length> values e.g., 10px, 2em, 50%, 3rem |
<number> |
Any valid <number> values e.g., 1, 0.5, -3, 100 |
<percentage> |
Any valid <percentage> values e.g., 50%, 100%, 25% |
<length-percentage> |
Any valid <length-percentage> values e.g., 10px, 50%, 2em, 75% |
<color> |
Any valid <color> values e.g., #ff0000, rgb(255, 0, 0), rgba(255, 0, 0, 0.5), blue |
<image> |
Any valid <image> values e.g., url(image.jpg), linear-gradient(to right, red, blue) |
<url> |
Any valid url() values e.g., url(‘https://example.com/image.jpg’) |
<integer> |
Any valid <integer> values e.g., 1, -10, 42 |
<angle> |
Any valid <angle> values e.g., 45deg, 0.5turn, 1rad |
<time> |
Any valid <time> values e.g., 1s, 500ms, 0.75s |
<resolution> |
Any valid <resolution> values e.g., 300dpi, 2dppx |
<transform-function> |
Any valid <transform-function> values e.g., rotate(45deg), scale(1.5), translateX(100px) |
<custom-ident> |
Any valid <custom-ident> values e.g., –my-variable, custom-identifier |
<transform-list> |
A list of valid <transform-function> values e.g., rotate(45deg) scale(1.5) translateX(100px) |
Let’s say we have a button component. We’d like to define some defaults on this component. Traditionally, we could use custom properties to define the background color and border radius of the button component, like so:
.button { background-color: #fff; border-radius: 8px; }
Or, use CSS variables to define the values once and reuse them throughout the stylesheet:
:root { --button-bg: #fff; --button-rounded: 8px; }
But, what if we want to ensure that the background color is always a valid color value, and the border radius is always a valid length value?
We can use the @property
rule to define the type of these custom properties and set default values.
To do so, we could create a couple of custom properties defined with the following options in the @property
rule:
@property --button-bg { syntax: '<color>'; initial-value: #0D74CE; inherits: false; } @property --button-rounded { syntax: '<length>'; initial-value: 8px; inherits: false; }
In this example, we have two custom properties defining the background color and border radius of the button component.
We use the syntax
property to define the type of the custom property, while the initial-value
property sets the default value.
We also use the inherits
property to specify whether the custom property inherits its value from its parent element, in which case we set them all to false to avoid inheritance.
Once they are set, we can now use these custom properties in our styles, like so:
.button { background-color: var(--button-bg); border-radius: var(--button-rounded); }
See the Pen CSS @property by HONGKIAT (@hkdc)
on CodePen.
The CSS @property
rule brings a significant step forward to CSS custom properties, or CSS variables. All major and latest browsers already support the CSS @property
rule.
Browser | Desktop Version | Mobile Version |
---|---|---|
Google Chrome | 85 and later | 85 and later |
Mozilla Firefox | 128 and later | Not supported |
Safari | 15.4 and later | 15.4 and later (iOS) |
Microsoft Edge | 85 and later | 85 and later |
Opera | 71 and later | 71 and later |
Samsung Internet | 14.0 and later | 14.0 and later |
To sum up, the CSS @property
rule is a powerful feature and a great addition to the CSS language that can help you write more maintainable and type-safe stylesheets. If you haven’t already, give it a try in your next project!
The post Getting Started with CSS @property Rule appeared first on Hongkiat.