Bolting a chatbot onto your database isn’t AI-powered analytics—it’s a chatbot sitting next to your database. The interface needs to change more fundamentally than that. But how?

Dashboards aren’t about displaying data anymore. They’re about mediating a conversation between humans and AI about their data. This shift changes everything about how we design analytics interfaces. The chart that used to be the hero of your dashboard? It’s now supporting evidence. The drills and filters you spent weeks perfecting? Optional. The navigation hierarchy that users had to memorize? Irrelevant once the UI dynamically adapts to the content.

The chart that used to be the hero of your dashboard? It’s now supporting evidence.

In 2026, we’re not tweaking dashboards. We’re redesigning what a dashboard even is. The question isn’t whether AI will transform data analytics — it already has. The question is what does the interface look like when the intention, thinking, and evaluation stay with the user, while the mechanics and heavy lifting of analysis shift to AI?

Of course, some things do not change. Like the core use cases that underpin all data analytics. These remain stable, whether a dashboard is AI-powered or not:

1. Know — What is happening?

2. Understand — Why is it happening?

3. Act — What should we do about it?

What Actually Changes for the User?

These universal use cases are here to stay, no matter which AI model is currently around. The most significant change happens with the role of the user:

• You ask questions → AI anticipates questions

• You search for insights → AI surfaces insights

• You interpret data → AI explains data

• You decide → AI recommends and you decide

• You act → AI acts and you supervise

Each of these shifts changes how users actually interact with analytics. Let’s unpack what each shift means for the user experience.

From Asking to Anticipating

You used to come to the dashboard with questions. “What happened yesterday? How are we tracking against the target? Which region is underperforming?” You’d navigate to the right view, apply the right filters, and search for answers.

Now the system tells you before you ask. You open the tool, and it says: “Here’s what changed since yesterday. Here’s what needs attention. Here’s something unusual in the Midwest data.” You still ask questions when you have them—in plain English now, not through filter menus—but the starting point has shifted. You’re responding to insights, not hunting for them.

From Searching to Surfacing

You used to spend your mornings clicking through dashboards. Drill into this segment. Filter by that date range. Compare these two regions. Scan the charts for anything that looks off. Most of the time, you find nothing. Sometimes you miss something important.

Now the system does the hunting for you. Patterns you didn’t know existed show up in your feed. When sales drop, you don’t discover the drop and then spend an hour figuring out why —the system tells you both at once. You move from reacting (”what happened?”) to anticipating (”what’s about to happen?”). The anomaly doesn’t just get flagged; it gets explained.

From Interpreting to Understanding

You used to stare at charts and decode them. Is that spike significant or noise? Is this trend good or bad? What does a 12% drop actually mean in context? The visualization gave you data; turning it into meaning was your job.

Now meaning comes first. You see: “Revenue dropped 12% last week, driven by a logistics delay affecting three distribution centers.” Then you see the chart that proves it. You’re not puzzling over visualizations anymore—you’re reviewing conclusions and deciding whether to act on them.

From Deciding Alone to Deciding with Recommendations

You used to gather the data, weigh the options, and make the call. The dashboard gave you information; synthesis was on you. You’d build your own mental model of trade-offs, often missing factors you didn’t know to look for.

Now the system does the synthesis. It shows you what to consider based on your data and your organization’s know-how. It runs the scenarios: “If you increase the price by 5%, expect this. If you hold, expect that.” It compares options with explicit trade-offs and tells you how confident it is in each projection. You still decide—but you decide faster, with better information, and with fewer blind spots.

From Acting to Supervising

You used to be the one who made things happen. See the insight, make the decision, execute the action, track the result. Every step required your attention.

Now you set the guardrails and the system operates within them. Workflows trigger automatically when conditions are met — reorder inventory when stock drops below threshold, adjust bids when performance falls outside range, flag accounts when patterns suggest churn. Parameters are optimized continuously based on what actually works. Your job shifts from doing to supervising: defining the boundaries, reviewing the outcomes, stepping in when judgment is needed. The system acts; you course-correct.

Form Follows Function

These aren’t incremental improvements—they are a fundamental shift in what analytics does. And a shift in function demands a shift in form. The interface patterns we’ve relied on for decades — static dashboards, filter hierarchies, chart grids — weren’t designed for this. So what replaces them? That is the UX question that matters. Here’s how the interface fundamentally shifts:

Information Flow: From Push to Pull

You used to go to the dashboard. Open the tool, scan the charts, and figure out what’s important. That’s pull — and it assumes you know when to check and what to look for.

AI-first analytics inverts this. The system pushes what matters into your workflow: alerts when metrics shift, summaries of overnight changes, and anomalies surfaced before you ask. This turns the home screen from a wall of charts into a personalized briefing. Notifications and feeds become primary interfaces. The dashboard doesn’t disappear, but it changes role — it becomes where you go to dig deeper, not where you start.

Views adapt too. Pre-built layouts assume everyone needs the same thing at the same time. They don’t. AI-enhanced dashboards reconfigure based on context, user role, and the question being asked. What’s relevant right now takes center stage, not what someone thought might be relevant when they built the layout six months ago.

Interaction Model: Dialogue Replaces Navigation

You used to click through filters, drill down hierarchies, and learn where things live. The dashboard had a structure; your job was to master it.

AI-first analytics lets you skip the navigation. Type “Why did revenue drop last week?” and get an answer. The query bar becomes as important as the chart area—because asking is faster than clicking. Chat interfaces appear alongside (or instead of) traditional controls. Filters don’t disappear, but they become suggestions, not requirements.

The bigger shift is that interaction becomes bidirectional. Traditional dashboards show; you look. End of exchange. AI-enhanced dashboards propose hypotheses and invite response: “Here’s what I think is happening” — and you validate, push back, or ask for more. This means new UI patterns: feedback buttons (”Was this helpful?”), refinement controls (”Focus on this segment instead”), trust indicators showing confidence levels and related data sources. The relationship becomes conversational.

Presentation: Narratives Replace Charts

You used to stare at visualizations and decode them. Is that spike significant? Is this trend good or bad? The charts gave you the data; it was your job to extract the insights.

AI-first analytics leads with explanation: “Revenue dropped 12% last week because of a logistics delay in the Midwest.” Then comes the chart that proves it. Text stops being an afterthought—labels, titles, footnotes—and becomes the primary content. Visual density matters less than reading flow. The interface is designed to be read, not just scanned.

This also changes how you navigate complexity. “Here’s your data, go explore” sounds empowering until you’re staring at 47 metrics, wondering where to start. AI-enhanced interfaces tell you where to look and why. Guided pathways replace aimless wandering. Related insights and suggested next steps appear automatically. Progressive disclosure shifts from user-driven (click to see more) to AI-driven (here’s what you probably want next).

The Core UI Tensions to Resolve

Here’s the catch: every shift creates tension. Give users too much AI, and they lose control. Give them too little, and you’ve wasted the technology’s potential. You can’t have it all, at least not without careful design choices. These are the core trade-offs:

• Chat vs. Dashboard: when to converse vs. when to visualize?

• Proactive vs. Overwhelming: how much information should AI provide?

• Trust vs. Automation: how much control does the user need to maintain?

• Simplicity vs. Power: how do you preserve capability while concealing complexity?

• Personalization vs. Consistency: how do you adapt views without disorienting users?

Each tension demands a design decision:

• Turn-taking: Who speaks when? User, AI, or data?

• Progressive disclosure: How to reveal depth without cluttering the surface?

• Explanatory design: How does AI show its reasoning and elicit trust?

• Error recovery: What happens when AI gets it wrong? Can the AI admit it?

• Agency preservation: How does the user stay in control?

The Interface Worth Building

Remember where we started? A chatbot next to your database isn’t AI analytics. But now we can see what the alternative might look like — an interface that anticipates questions, surfaces insights, explains itself, recommends actions, and operates within guardrails. Not a dashboard with AI. A conversation with AI about your data, mediated by the right design.

The user opening an analytics tool in 2026 doesn’t want to hunt for insights, decode charts, or navigate filter hierarchies. They want answers. They want explanations. They want to decide and move on. Every interface choice we make either serves that goal or gets in the way. The dashboard isn’t dead — but its job has changed. It’s no longer about displaying data. Dashboard is about making data useful to humans who have better things to do than stare at charts. That’s the interface worth building. Design accordingly.

When a stakeholder asks for a dashboard, the temptation is to immediately open your design tool and start drawing charts.

Resist that urge.

Starting with visuals without understanding the user’s needs and pain points is a direct path to failure. Or more precisely, it is the path to building a ”Zoo of Exotic Charts.” You know the type: visualizations that look beautiful in a portfolio but are confusing and impractical for actual work.

Users don’t come to your dashboard to admire colorful bars or intricate shapes. They come to:

1. Solve problems.

2. Gather insights.

3. Leave with clarity.

To deliver that clarity, you must ignore the chart types (for now) and start asking your stakeholders and users the right questions.

The Discovery Checklist

Before drawing a single bar or line, ask:

• The Goal: What is the objective of this dashboard?

• The Problem: What specific issue are we solving?

• The Users: Who are they, what are they looking for, and why?

• The Context: How does this fit into their daily workflow?

• The Action: What are their next steps once they see this data?

Notice what’s missing? There is no question about pie charts, heat maps, or sankey diagrams.

Those answers come last. The answers to the user-centric questions will dictate the dashboard’s architecture. Once you understand the intent, the chart type becomes obvious.

Don’t work backward from a cool visual. If you do, you aren’t building an analytics tool for users—you’re just building a zoo for stakeholders.

Charts, visualizations, or insights are the building blocks of all dashboards, so choosing the right chart type is one of the crucial skills when building a dashboard. Pick the wrong one, and you can confuse or misinterpret the data or even make a wrong business decision with a lasting impact.

In this article, I will share my experience designing real-life business dashboards and other data-heavy applications, focusing on chart types.

In the previous post about building dashboards users actually love to use, I discussed the general principles of building a dashboard. In this one, I’ll focus on the details of the dashboard’s building blocks: the charts. And you better know your charts well before building the dashboard. So let’s get started.

Start with the use case - ask the most important question first

I could just list all available chart types here like in every other article on the internet, but I think this approach leads to thinking chart-first and creating already mentioned exhibitions of charts. And you don’t want to build an exhibition. You want to deliver a message with your charts and dashboards - to have an impact on your users. Keep that in mind whenever you feel the urge to use the random but nice-looking chart you just saw in some infographics!

When deciding which chart to use, you should always start with the most important question:

What do I want to show to my users?

• Show one big number

• Compare values within and between groups

• Show the composition of data

• Display change over time

• Explain the relationship or flow between metrics

• Plot geographical data

• Show the details of many items

These seven use cases will cover 99% of your data visualization needs. If you answer the question with a use-case, meaning with what you want to deliver as a message, and not directly with the chart type, you’re on the right path. Let’s now dive deeper into the details.

Show one big number with a Headline

Just because you have numbers, there is not necessarily a reason to create a chart. Showing a Headline (or KPI - key performance indicator) is a great way to convey critical metrics, whether you build a marketing, project management, or supply chain dashboard. Good examples of Headline-worthy numbers are the following metrics:

• Number of sold items

• Gross revenue, net revenue

• Number of visitors to a website

Two very important pieces of information must come along with a Headline:

1. The related date range or time frame means the time span represented by the Headline. Typically, this is a date filter on the dashboard or indicated in the title. There is a big difference between yesterday’s and last year’s gross revenue, and the user should be told which he is looking at.

2. Context. Showing the number alone is not enough. You need to give it context, such as showing the difference from the previous period, showing a secondary metric, or comparing it with another metric. Users cannot tell if the number should make them smile or cry without context.

Compare values within and between groups using a bar chart, column chart, or bullet chart

One of the dashboard's most common use cases is comparing countries, products, departments, etc.

• What is the population in European countries? 

• What are my sales numbers in those countries? 

• Who are the top salespersons in my company?

All these questions can be answered by the most well-known and used charts - bar charts and column charts. These names are sometimes used interchangeably, but typically, the columns are vertical, and the bars are horizontal (to remember the direction - picture all those ancient Roman buildings with columns). The meaning stays the same - the length of the bar (or column) represents the value. Don’t shy away from using bar and column charts. They might be omnipresent and well-known by users, but that is their biggest strength - they convey the message in the most understandable way.

Both bars and columns in your charts can be grouped (sometimes called clustered). For example, if you want to show the comparison not just between countries but also within countries, the grouped bar chart is a good option to show, e.g., the average age in countries (group) but also between men and women.

Another option is to stack (or segment) bars in your chart. This step further divides the data in each bar (column), meaning the chart can answer questions like sales in different regions and across multiple product categories. The bars in the stacked bar chart can be a simple sum of values to show the total, or all bars can be stacked to 100% to show the relative value of each category.

You might need to go one step further beyond simple comparison. For example:

• Who are the top salespersons in my company, and what are their goals?

• How is this person doing in comparison to a company benchmark?

A bullet chart is a great way to display answers to such questions. The main bar displays the current value, the secondary bar can show, for example, a previous period value, and the symbol marker typically indicates a goal or benchmark value.

Show the composition of data utilizing a pie chart, donut chart, treemap, pyramid, or funnel charts

Anytime you need to show a simple composition or part-to-whole (how the share relates to the total amount), this class of charts comes in handy. For example:

• Allocation of women and men among your customers

• Approved and denied applications for a school

• Share of 1 region’s sales on the whole company sales

These kinds of questions could be very well answered by a pie chart or donut chart. On the other hand pie and donut charts should come covered in black and yellow warning signs saying do not use for more than two or three categories! Humans are awful at comparing angular distances – the sizes of slices – if there are too many. If you want to compare more categories, skip these two and read on.

A pyramid chart can be highly effective when you want to display data in a hierarchical structure with a clear progression from one level to the next.  It helps to answer the questions like these:

• How does the number of top-level executives compare to entry-level employees?

• What is the breakdown of product sales through different tiers?

• What are the proportions of employees at different job levels within the organization?

Funnel charts are inverted pyramids, and they are perfect for showing a linear process that has multiple stages, particularly when there is a noticeable drop-off from one stage to the next. For example:

• What percentage of leads move through each stage of the sales funnel?

• At which stage do we lose the most potential customers?

• How effective is our onboarding process in retaining new users?

Imagine you need to display an even more complex composition, such as a two-level hierarchy. This is where a treemap becomes particularly useful. For example:

• Population distribution: Showing the number of humans per continent and then breaking it into individual countries.

• Marketing budget allocation: Displaying the budget across different marketing campaign categories and further detailing specific campaigns within each category.

• Sales performance: Highlighting overall sales by product categories and then delving into individual sales within each category.

A treemap is ideal for visualizing such compositions. Its rectangular layout allows for a more intuitive understanding of hierarchical data. Each rectangle represents a category, with the size of the rectangle corresponding to its value. Within each category, smaller rectangles represent subcategories, making it easier for the human brain to compare areas and perceive the relative sizes of each segment.

Display change over time with a line chart, area chart, or column chart

Showing the evolution of any metric over time is one of the most common use cases while designing a dashboard. A few examples might be:

• Sales trend over the past year

• Number of webpage visitors trend

• Amount of support tickets coming to your help desk day by day

All those use cases have in common that they show the progress of a metric in time. The change from one period to another is the key message these charts communicate.

A line chart, area chart, and column chart are the most common chart types used to visualize change over time. In most cases, they can be used interchangeably, but subtle differences exist between them. Line and area charts are the best tools to visualize data that goes up and down daily. For example, the number of tickets in your backlog, the amount of money in a bank account, or the temperature. On the other hand, column charts are the best choice for data that starts at zero every period. Like the daily number of support tickets, monthly sales numbers, or webpage visitors.

Now imagine you want to display a sales trend of your four different product categories. What is the key message here? Do you want to compare them against each other or show their share of the overall sales performance? The former is best done with a line chart with multiple lines, the latter with a stacked area chart.

One last example of displaying time, although on a cyclical basis, the most popular are hours, days, or months. For example, what are the busiest hours on your hotline during the week? Heatmap is a fantastic type of visualization for exactly this use case.

Explain the relationship or flow between metrics with a scatter plot, bubble, combo, or waterfall chart, dependency wheel, or Sankey diagram

Explaining a relationship or correlation between two metrics can be very beneficial since it’s one step towards getting valuable insights from the data. If you ever need to answer a question like the following examples, the scatter plot is the best choice:

• How does the campaign spend relate to its revenue across many different campaigns?

• What is the relationship between the number of orders and total revenue by the product category?

• How many courses did each student start and finish?

Each campaign, product category, or student is represented by the dot on the chart, and each metric is then encoded on one of the X and Y axes.

Adding a third metric to the mix brings an extra level of insight but also an extra level of complexity. This additional metric is typically represented by the size or the color of the dot, which then becomes a bubble and, therefore, a bubble chart. A few example questions that can be answered with bubble charts are:

• How many courses did each student start and finish (X and Y axis), and what university did they study at (bubble color)?

• What is the relationship of the company’s total revenue in each country (bubble size) to the number of stores in that country (Y-axis) and to the number of employees in that country (X-axis)?

• Or one of the most famous bubble charts by Hans Rosling - how do the country’s GDP per capita (X-axis) and population (bubble size) relate to life expectancy (Y-axis)?

Relationships or correlations between two metrics can also be shown over time. For example, the number of visitors and the revenue of the e-commerce website. In that case, a combo chart consisting of a column chart and a line chart comes into play. With two independent Y axes, it is possible to show the relationship even between metrics with vastly different scales.

Waterfall charts are ideal for showing how an initial value is affected by a series of intermediate positive or negative values, leading to a final value. They provide a clear visual representation of the cumulative effect of sequential data, answering questions like:

• How did each department contribute to the company's quarterly profit?

• What were the main drivers behind changes in net profit?

• How did individual expenses and savings impact the project budget?

Dependency wheels are powerful tools for visualizing the relationships and dependencies among multiple entities or variables in a circular layout. They are frequently used in network mapping, supply chain analysis, and project management to illustrate complex connections. By using dependency wheels, you can answer questions such as:

• How are software modules interconnected?

• What are the key interactions between departments?

• Which tasks in a project are interdependent?

Sankey diagrams are excellent for showing the flow of resources, such as energy, money, or data, between different stages or entities. They make it easy to follow the movement and proportion of resources. Typical use cases include:

• Tracking the flow of funds in a budget.

• Visualizing the energy consumption and losses in a system.

• Mapping the distribution of traffic on a website from different sources.

Plot geographical data on the map

Whenever you need to display geographical data, it’s kind of obvious to put them on a map. For example:

• Distribution of customers across states

• Number of people living in the cities

• Revenue per region

The location is a generally understood concept, and a map provides a direct connection to the data. On the other hand, having geographical data does not mean the map is the best option. For example, if you need to display a relationship between two different metrics for a single geographic location, e.g., the number of stores in a state and the average sales for that state, it’s better to go back to scatter of bubble charts than try to cram too much information on the map.

There are two main ways to display data on a map. To fill the area (e.g., a state) or to use a pushpin or other shape over the target area. In most cases, I would suggest using the pushpin on the map over the filled areas (a filled map is sometimes called a choropleth). Why? Because the size is psychologically perceived as a stronger indicator than the color shade. Therefore the poorly performing large states (let’s say Alaska) will overshadow much better-performing small states (for example, Massachusetts). In other words, geographic significance does not translate to data value significance.

Also, be sure to use the map only as a background; the data points are the stars of the show.

Show the details of many items as a good old table or repeater

Yes, although they might not be the most striking kind of visualization, tables sometimes have their place on the dashboards. The fact that you have data to show does not mean they need to be shown as a chart. Sometimes, the best shape for the data is still the humble table.

The table needs to make sense in the context of the whole dashboard, though. For example, a dashboard focused on orders from the e-commerce store, showing various overviews and summary charts, and in the end, it can show all the separate orders in a table. So you can see the order details or even drill from the dashboard directly into your system to see all the details of that particular order. Other examples could be:

• Product details - product category, items sold, average price, % of revenue

• Customer details - name, email, # of orders, total revenue

• Support agents - name, position, # of assigned tickets, # of resolved tickets, CSAT

Generally, if you need to list details of a group of items, the table is usually a good choice. Especially if it’s part of the dashboard, it is interactive and allows users to sort columns, drill into other dashboards, etc.

Last but not least, having at least one table on the dashboards could also serve as a negotiation trick for the more stubborn stakeholders unwilling to leave Excel, their safe and familiar space. 

Repeater is a sort of fancy table containing small charts. It is a versatile tool for showing detailed data in a structured, repeating format. It is particularly useful when you need to present a lot of items with multiple data points, such as:

• Product performance across different metrics

• Employee performance metrics

• Monthly sales figures for multiple products

Repeater combines the information density of tables with the visual clarity of charts. Each cell in a repeater can display data as numbers, bar charts, or line charts, with additional support for rich text content, including images and links. This flexibility allows for a comprehensive and interactive data presentation.

Stay boring, avoid exotic chart types

So, the other day, you went on the internet and found some exciting visualization to spice things up a little on your dashboard – something like you can find in the Xenographics zoo of data visualizations. Well, forget about it. Some of those charts might look cool on some fancy infographics but not on your typical dashboard. Again, the dashboard is about understandability. Be a little boring with the chart types on purpose. The users of your dashboards will thank you.

Summary of the key principles

We’ve explored 99% of the most common use cases of data visualization and the most useful chart types. The visual part of the data presentation is really important, but remember that the focus should be on following the use case and delivering the message to your audience. Adhere to the mentioned principles, and you can't go too wrong.

• Start with the use case

• Show one big number with a headline

• Compare values within and between groups using a bar chart, column chart, or bullet chart

• Show the composition of data utilizing pie charts, donut charts, treemaps, pyramids, or funnel charts

• Display change over time with a line chart, area chart, or column chart

• Explain the relationship or flow between metrics with a scatter plot, bubble, combo, or waterfall chart, dependency wheel, or Sankey diagram

• Plot geographical data on the map

• Show the details of many items as a good old table or repeater

• Stay boring, avoid exotic chart types

Do not build exhibitions of charts. Build usable and understandable dashboards instead!

If you want to try any of the mentioned charts, you can register for the GoodData trial and play with them on your own.

This article was originally published in December 2022. In July 2024, it was updated and expanded with more chart types supported by the GoodData platform.

Imagine the beginning of a typical technical implementation project. It starts with a conversation. Business stakeholders present their grand visions through countless PowerPoint slides, software architects map out intricate technical diagrams, and designers contemplate the perfect shade of purple for a home screen. Each group talks in their own tribal languages of slides, diagrams, and high-fidelity mockups. However, these languages rarely align, and the involved parties don't understand each other. These initial conversations, hindered by misunderstanding, often lay the shaky foundation for failed software projects.

Communication is the key

So, how can we get everyone on the same page? Better communication. Effective collaboration requires a common language. The project is more likely to succeed when different parties understand each other.

What works best when people don't share a common language? Visuals! Simple drawings, sketches, and squiggles can convey ideas universally. In the business world, the equivalent of this visual language among the various corporate tribes is a wireframe.

Wireframes in complex software projects are a great tool for getting the message across. Making the first step from vague ideas and words into something visual. They are easy to understand, quick and easy to create, and even quicker to adjust or discard and redraw from the beginning. They convey the message that this is all up for discussion, suggesting a rather tentative concept and encouraging feedback and refinement without the pressure of perfection. They are clearly just blueprints, and no code has been written yet. They are not art, and people don't feel bad about criticizing them. They convey just the right amount of detail to allow focus on the important stuff and not stuck on details. They are very approachable – you don't need a PhD to create a simple sketch on a paper or a whiteboard.

Wireframes support iterations

Implementing the first idea that comes to mind can be costly if it’s wrong. Building something that nobody wants to use, could not be used, or is simply wrong is surprisingly easy. Wireframes support quick iterations, allowing ideas to evolve and improve. Tools like Figma make it easy to add important details and interactivity, enabling early functionality testing with real users. Real-world feedback, served early and often, helps ensure the final product meets user needs.

From idea to code

The journey from idea to final product in software development is often long, twisty, and uncertain. Wireframes serve as a crucial communication tool throughout this journey, facilitating the transformation of ideas into code. Much like a simple napkin sketch clarifies ideas in conversation, wireframes enhance understanding and alignment among team members.

How I use wireframes

No matter the project type, if the end result is software, wireframes are my go-to tool. I start with rough sketches with pen and paper, then switch to Figma and wireframing libraries like GoodWire for more detailed iterations on analytics dashboard prototypes.

As a UX designer on GoodData's customer projects, I convert client requirements into detailed dashboard blueprints. The wireframes are my first visual replica of a longer conversation between me and the client. They represent the very first tentative concept and present the idea this is how I understand your requirements. What do you think? Wireframes invite conversation so well that it's only natural and easy to discuss them, change them on the fly, or completely overhaul the design from scratch.

Through several iterations, we create an interactive prototype that showcases the information architecture, chart layout, and interaction details. This prototype is tested with stakeholders and users, allowing for adjustments based on their feedback, which is much faster and cheaper than developing a full product upfront.

What are the drawbacks of wireframes?

While wireframes are highly effective, they can cause confusion if not used correctly. It’s crucial to communicate that their low fidelity and fifty-shades-of-grey color palette are intentional. Avoid filling wireframes with too detailed placeholder data that might distract stakeholders. Instead, focus on high-level structure and information architecture to guide the discussion.

How can you start using wireframes?

Starting with wireframes is simple: just begin sketching your ideas. Whether on paper or using tools like Figma, wireframes can transform your project’s communication and development process. Embrace this visual language to bridge the communication gaps, enhance collaboration, and ensure your final product aligns with user needs. Try incorporating wireframes into your next project and experience the difference they make.

By now, you have probably mastered the basics of using the GoodWire, as outlined in the previous article. If not, I highly recommend you pause here and start with the Getting Started with the GoodWire article. It outlines the basics of getting and setting up the library and working with various components.

And now, let's dive into the more advanced prototyping tips to take your wireframes to the next level.

1. Annotate your wireframes

By default and by intention, the GoodWire has a pretty low level of fidelity. You only really need a few components - chart type, approximate complexity/number of data points, title, and axis labels. That's it. Most of the time, you won’t need anything else, but sometimes, you still need some extra commentary to explain the interactivity or other details.

Sticky notes are useful for annotating your prototypes beyond the fidelity of the available components—for example, to indicate the slices of a donut chart or stack in the column chart. The Note component is available on the Components page of GoodWire in various colors and sizes.

If the notes do not fit the desired space, you can use Figma's default Arrow shape to point it to an exact spot. Just hit Shift + L and drag your arrow.

2. Create interactive navigation

You will eventually present your dashboards to your stakeholders or test them with future users - that is one of the main purposes of the wireframe. So, helping them imagine how the dashboards will work in practice can go a long way.

One of the best ways to help their imagination is interactivity. Don't worry about the number of steps needed; it's quite fast and well worth it.

1. Start by creating your dashboards.

2. Duplicate the Dashboards menu component outside of your dashboards.

3. Create links to all dashboard pages from separate menu items:

   1. on click - Navigate to

4. Create a component out of the Dashboards menu

5. Replace the menu on all the dashboards with its instance. That way, the interactions (navigation between pages) will be duplicated automatically across all dashboards.

6. Now, you can adjust the states of menu items to match the selected dashboards.

7. Last step - add a Flow starting point to your first dashboard and enjoy the working prototype!

See the video of creating the interactive navigation step by step:

You can also see the Demo dashboard live prototype and explore the navigation on your own.

3. Drill to modal window

GoodData platform also supports another type of interactivity - drilling into the visualization. That means showing a particular visualization in a modal window. You can learn more about this interaction pattern and how to set it up in the GoodData documentation.

Now let's look at how to set it up in the Figma prototype:

1. Insert the Modal component on a canvas outside your dashboard

2. Detach the Modal component so it becomes a Frame

3. Insert your chart into the Modal frame and adjust it as needed

4. Select the chart element on your dashboard that will trigger the drill

5. Switch to prototyping mode

6. Drag the connection to the Modal and set it as follows:

   1. On click

   2. Open overlay

   3. Instant

   4. Centered

   5. Check Close when clicking outside

   6. Check Add background

   7. Set background color to #FFFFFF at 75% opacity

7. Done. Play the prototype and check how it works.

Bonus tip: Set the X button in the modal to close it:

1. Select the X button

2. Drag the prototyping connection to the Close overlay

4. Create sticky navigation

Effective presentations sometimes hinge on little details. For example, there is a scrolling behavior. The dashboard menu, title, and filters stick to the top of the page when the user scrolls in the GoodData platform IRL. You can easily simulate this behavior with Figma prototyping capabilities and give your prototypes a nice final touch.

Here's how to do it:

1. Group the Dashboard title and Filters bar

2. Select the group you just created and the Dashboards menu and bring them front in the layers hierarchy

3. Switch to prototype mode and set Scroll behavior - Position to Sticky (stop at the top edge) for both the grouped title and filters and for the dashboard menu

Done. Play the prototype and enjoy.

Bonus tip: Dashboard building best practices

Now, you should know the moves for assembling dashboard components in Figma. But there is more to it - the whole craft of analytics product design. Before you start building the dashboards, I would advise you to familiarize yourself with general dashboard-building principles. You can start by going through the following articles to learn the basics:

In the article 7 Crucial Tips for Building Dashboards Users Actually Love to Use, you'll learn a few crucial tips to get you started. You'll discover how to define the problem, understand user requirements, and focus on simplicity and clarity. Additionally, you'll learn to use appropriate visualizations, ensure data accuracy, and continuously iterate based on user feedback to develop engaging and user-friendly dashboards.

Next is the article How to Choose the Best Chart Type to Visualize Your Data. It covers the key considerations for choosing the right chart, such as understanding your data, the message you want to convey, and the audience's needs. You'll explore different chart types and their optimal use cases to enhance the clarity and impact of your data presentations.

Another important aspect of dashboard building is the information architecture. Check the article Six Principles of Dashboards Information Architecture to learn about the key principles of dashboard information architecture that ensure an intuitive and effective user experience. It covers essential guidelines on structuring and organizing data, emphasizing clarity, consistency, and ease of navigation. By following these principles, you can design dashboards that make data insights easily accessible and actionable for users.

Are you tired of cumbersome wireframing for your data dashboards? Meet GoodWire, your new best friend in dashboard prototyping. The GoodWire wireframing library is a robust collection of UI components and chart types designed specifically for prototyping data analytics applications on the GoodData platform. This library provides everything you need to quickly prototype and iterate on your designs, ensuring a smooth and efficient workflow. 

With GoodWire, you can focus on crafting a solid information architecture and displaying the key data points in a way that supports your users' decision-making processes. I introduced the library in greater detail in the previous article, so feel free to catch up on that one first if you want more context.

Now, let's look at the steps you need to take to utilize all the power GoodWire offers. First, you need to have your Figma, and then you need to get the actual Figma library.

1. Download the library from Figma Community

First things first - you need to download the library from the Figma Community page. It's free.

1. Go to the GoodData GoodWire Figma Community page

2. Click the big blue Open in Figma button

Done. Now, you have your own copy of the GoodWire wireframing library file. Feel free to look around. But for now, it is only like any other Figma file, sitting in your drafts - not yet a real Figma library. Once you are ready to level up, go to the next step - and use the file as a library.

2. Use GoodWire as a component library

To fully utilize the design library, you must publish it to your organization or team first. Just a note: To use libraries, you must have any paid Figma plan—Professional, Organization, or Enterprise.

1. Move the file from your Drafts, typically to a Design system, Components, or similar project. In the end, anything but Drafts will work—if you keep the file in your Drafts, nobody but you can use it, and even you cannot use it as a library. And that would be a pity.

2. Select Publish library… from the dropdown menu

3. Select the whole organization or just one team (current location of the library)

4. Click Publish

5. Wait a few moments (about a minute or two) before the library is assembled and published

Now, you want to enable the library in your organization, team, or specific design files. When done, all the components from the library will be available in the Assets tab.

Let’s look at how to enable the library in your team:

1. Open team settings

2. Select View team’s libraries

3. Locate GoodData GoodWire and enable it for All files

4. Done - now you can see all the components in the Assets panel for all files in your team

You can also enable the library for your whole organization or just a single file - learn more about working with libraries and managing them here in the Figma documentation:

• Manage libraries in the design files

• Manage libraries in your drafts

• Manage team libraries

3. Library structure

The GoodWire wireframing library is quite simple. It contains two main parts:

1. Components - all the necessary components of GoodData’s UI and a few useful generic wireframing components like sticky notes

2. Charts - the meat of the file. The library contains all of GoodData's 21 chart types and hundreds of their variants, so you can prototype almost any scenario of your data product. 

Other pages help you understand the library (How to) and give you an idea of what you can do with it (Demo). The demo is a good place to start your exploration if you are unsure what to do and would like some inspiration or tips on assembling dashboards.

4. Check the demo dashboard

The demo page contains a fully assembled prototype of dashboards built from 4 pages—check it out for some inspiration. Also, if you have no idea where to start, check the Demo first. That way, you will understand how the pieces fit together.

Hint: You can also hit the play button to launch the Figma prototype and see the dashboards in action—how the end user will see them. The menu on the left allows you to navigate between pages of the prototype. Also, look for the blue targets for more interactions. 

The prototype is also the best way to communicate the results of your work with stakeholders - in a clean prototype environment, not in a messy design file.

Launch the live prototype here or check the video walkthrough below:

5. Set up an empty dashboard

The empty Dashboard component is a container for all your charts. But when you drag it out of the Assets tab, it's a component with all its limitations - you need to detach its instance to use it as a proper container for your charts.  But don't worry, you won't lose any important functionality:

1. In the layers panel, expand the Empty Dashboard instance and select the subcomponents:

   1. Dashboards Menu

   2. Filters Bar

2. Detach them. The Empty dashboard now becomes the Artboard, which works as a container for all the charts.

You’ll want to work with the menu and filters beyond Figma's components capabilities - mainly to add and remove menu items and filters. So they need to be detached from the original component in order to allow such modifications.

6. Adding charts to the dashboard

Now you can start adding the charts to your empty dashboard. Drag them from the Assets panel or use the Resources panel (keyboard shortcut Shift + I) for faster prototyping.

The empty dashboard is 1430 pixels wide by default - 230 pixels for the menu and 1200 pixels for the charts. The default width is 600 pixels for most charts and 300 pixels for headlines (KPIs), so you can fit 2 charts or 4 KPIs side by side neatly out of the box. But feel free to change the size as you like. GoodData dashboards work with 12 column layout, which is simulated by the pre-determined sizes of the charts:

7. Adjusting charts

Every chart type comes to the dashboard in its default configuration. But behind the scenes, every chart contains multiple, sometimes even dozens of variants - e.g., the number of columns in the column chart or slices in the pie chart. So you can, for example, easily represent weekly (7 columns) or monthly (30 columns) trends. You can change the chart properties from the properties panel on the right. 

You can also use the Properties panel to swap the chart types. For example, if you swap the column chart for a line chart, you don't need to delete it; just change the chart type.

Note: not every combination of properties is supported by the library—please see the Charts page to see all the currently available chart variants.

Now it is up to you!

These are the basic tips to get you started with the GoodWire wireframing library. Go and try it yourself. Download the GoodWire library today and transform your dashboard's prototyping process! Build your first dashboard. Iterate on it and discuss it with your coworkers. But mainly - build it in GoodData. The wireframes are not the final product, but they will help you.

In the next article, I'll share some tips and tricks to take your dashboards to the next level, focusing on creating interactive prototypes.

Building a dashboard without a proper plan is a tried and tested recipe for a failed project. Before diving deep into the data, you need an idea about the dashboard's design. What will it look like? And more importantly, how will it meet the diverse needs of various users and support their use cases? Projects typically involve multiple roles with different specializations—technical, business, and design experts—all speaking their own languages, whether through technical diagrams, textual descriptions, or high-fidelity mockups. Despite these challenges, it's essential to move swiftly and iterate rapidly.

Wireframes: The Ultimate Communication Tool

Wireframes offer an ideal solution. They bridge communication gaps between all project roles, being universally understandable and easily adjustable. Quick to create, update, iterate, or even scrap and restart, wireframes are not the final product but a collaborative tool to reach consensus on a dashboard design.

Wireframes also strike the perfect balance between simplicity and detail. They provide enough information to outline the structure and functionality without overwhelming the team with unnecessary specifics. This lets you focus on crafting a robust information architecture and highlighting the most crucial data points, ensuring that the final design effectively meets users' needs.

Want to see it in action? Check out the interactive dashboard prototype built in Figma using the GoodWire library and see for yourself.

Introducing GoodWire wireframing library

The GoodWire wireframing library is designed for maximum efficiency. It offers a comprehensive suite of UI components and chart types tailored for swift prototyping of data analytics applications on the GoodData platform. Featuring all essential elements of GoodData's UI and a vast array of 21 chart types in over 400 variants, this library equips you with everything needed to quickly prototype and iterate on dashboard designs, ensuring a seamless and productive workflow.

Built to facilitate discussion and rapid iteration, GoodWire allows your team to focus on creating a robust information architecture and clear presentation of key data points. Over the past several years, I've developed and refined this library through dozens of customer projects, ensuring its robustness and reliability in real-world applications.

Get started with the GoodWire library in three simple steps:

1. Download the file from the Figma Community

2. Connect it as a library

3. Start designing your dashboards

Take action today. Empower your design process with GoodWire and transform your data into insightful, actionable visualizations. Build dashboards in minutes and revise them in seconds.

Getting real

Ready for the obvious next step? Bring your vision to reality with the GoodData platform! Give it a try with GoodData's free trial! All you need is your wireframe and some data—even a CSV will do. It’s that simple.

The world of generative AI product development currently resembles the Wild West. Billions of investment dollars are pouring in, along with massive interest from both consumers and enterprises. The development is so fast-paced that it seems like a future you only read about in sci-fi books is already here. Or at least if you're following the AI progress these days, it looks like it. But as William Gibson famously said: "The future is already here — it's just not very evenly distributed." The distribution part is important here. Just ask your mum what excites her the most from the latest AI innovations. With the pace of technological advancement unprecedented, it can be pretty challenging for any product team to stay focused amidst all this chaos and not jump on every new hype wave.

Everyday users don't really care about the latest prototype

Standing in the middle of all this AI development chaos are the users - not just the AI-news-following users, the innovators and early adopters, but all types of them. Imagine any Gauss curve of technology adoption. Most people don't really care about the latest developments in the area of AI - they want to do their job and go home. It's okay - for most people, it's about having a solid and reliable tool to work with, not the latest prototype from the innovation lab. So, you won't win users' hearts if you make their work harder or more complicated.

Putting a chat interface on top of any app won't cut it

Generative AI in its current form is mainly represented and controlled by chat interfaces. But that is just one of the possible interfaces - beneath, it's so much more than a simple chat. Unfortunately, many companies use generative AI in their products with little creativity. They rush to slap an AI chat interface on top of their existing product as a quick and obvious solution - without much consideration of whether the chat interface may not be the best solution for every problem. Putting a conversational interface on top of your existing app, connecting some APIs to OpenAI, and hoping for the best won't cut it. People are creatures of habit, and they don't change easily. Removing all their buttons and other familiar UI elements and replacing them with a chat interface won't make them very happy.

The challenges of AI chat interfaces

The chat interface poses a major challenge for the users - simply because writing is hard. Formulating the requests in a written form, including all the parameters as prompts, is even harder. Jakob Nielsen even labels this as a completely new UI paradigm - intent-based outcome specification. More so, when the usual controls like buttons and sliders are gone, and all that is left is a chat window, the app suddenly has much fewer affordances, and users are not aware of all the possibilities they can do - recognition rather than recall is still a valid principle in user interface design. Lastly, since generative AI is so technologically complex, the projects are typically engineering-led without significant UX/UI involvement. Just remember the cumbersome flow of image creation in Midjourney through the Discord server.

How to approach the UX of AI?

As UX professionals, developers, and product managers, we have a great and exciting challenge ahead of us - to find ways to integrate AI-driven automations meaningfully into our products. To focus on enhancing the current users' workflows - making them easier, faster, more efficient, or more enjoyable - or inventing entirely new ways to do things enabled by the power of AI. But do not try to force every interaction through that ubiquitous chat window. Try to resist this urge. Using a chat interface for everything is like looking at the world through the letterbox in the door. Sure, you can do it, but you'll certainly miss many opportunities.

Design for AI needs to go beyond the chat window

The design for AI needs to take much more into account than just a single interface element and try to force every interaction through it. It needs to go beyond the chat window - start with the users and their needs and only then look for ways and interface elements to solve them. Avoid cramming every interaction through the chat window - users should not be forced to carry the burden of the interface complexity. There are many ways to utilize AI in products that are not overhyped and make sense. Let's review several examples of well-executed AI implementation in existing products.

Miro's AI Assist

With its AI Assist, Miro took advantage of what the current generative AI can do best - generating and summarizing large amounts of text - and put those features in reach with clever in-context controls. Miro can generate new branches in the mind maps, summarize or cluster stickies with notes, or create basic presentations. It's simple and useful - and also accessible for the users since those features are available through buttons and not just a chat window.

Grammarly's AI Assistant

Another great example is Grammarly. They used machine learning to check your speling spelling and grammar for years. Now, with the help of AI Assistant, Grammarly allows users to generate ideas for text improvements, change the tone or style of the text, make it longer or shorter, search for inconsistencies, and many more. Similar to Miro, Grammarly is an excellent example of a contextual tool - its omnipresent green icon pops up wherever you write anything, so it's never too far away and fits nicely into the existing writing workflows.

GoodData's FlexAI

We approach the generative AI with similar contextual intent in GoodData - to provide AI in meaningful places to improve users' workflow - to provide forecasts, cluster the data, analyze the key drivers behind metrics, or explain the visualizations. These various in-context features help users get the most out of the dashboards without additional data analysis tools.

The forecasting feature in the line chart predicts future data trends based on past patterns, visually extending the chart to offer insights into what might happen next. This feature predicts the future development for the selected amount of periods, including the estimated error bands.

The data clustering feature in the scatter plot color codes similar data points, making identifying patterns and relationships within the data easier. This visualization aids in distinguishing between different categories or behaviors by visually separating them into distinct clusters.

Key driver analysis in data visualizations identifies and highlights the factors that significantly impact a specific outcome or variable. It allows users to choose the metric and explain what drives the most increase or decrease in the selected metric. This analysis helps understand the relationships and influences of different variables, guiding decisions and actions based on the dashboards.

And, of course, there's an AI chat interface. GoodData's FlexAI Assistant allows users to interact with data and dashboards by enabling conversations in natural language - making analytics more accessible and eliminating the need for complex querying. This generative AI chatbot can deliver quick business insights, explain complex visualizations, or create analytical objects like metrics and visualizations on the fly.

The FlexAI Assistant comes with a great challenge of trust connected with using AI for data analytics - how can I trust the numbers produced by the AI chatbot? Current generative AI is excellent at creative tasks like generating texts or images. But sourcing the answers from business data is a bit different. Actually, it's very different. It must be crystal clear that AI is crunching the actual business numbers, not making them up. Users need to have certainty that they can trust the results. That is why the FlexAI answers contain the explanation of the results - that the gen AI did not calculate the numbers but put together a standard metric that did the calculation.

Design beyond the chat window!

The world of generative AI product development is experiencing unprecedented growth and investments. However, amidst all this rush, the users are the ones who matter the most. To effectively integrate AI into products, companies need to focus on enhancing current users' workflows or invent entirely new ways to do things enabled by the power of AI. However, simply adding a chat interface to an existing product won't cut it. It's time to think beyond the chat window.

Are you interested in AI-powered data analytics?

Sign up for the GoodData Labs for free if you want to try any of these features with your data!

Humans looking at screens, touching some of them, pushing buttons, and pushing the mouse around are the main interaction patterns between humanity and technology these days. The form factors are limited mainly to screens of various sizes.

• Honey, welcome home. Did you have a good day looking at screens at work?

• Yes, screes were good today. How about your screens?

• Mine were not so good. Let's watch something on our big screen.

• Ok, I might touch my small screen while watching.

Looking at various screens is familiar and comfortable for most people. And since humans are creatures of habit, it's hard to convince them to start using something completely new. Many products tried, but only a few succeeded.

The screen-first interaction pattern is strongly connected with another one: application-first. There's an app for that is Apple's famous slogan, which represents the fragmentation of use cases between separate applications. Creating spreadsheet? Editing photo? Searching for a recipe? Following a football game? Watching videos? Posting to social media? Any other imaginable task, including tracking of those tasks? There's an app for that.

Another category of devices, currently in the minority, is voice-first products. Typically, they are home or personal assistants like Alexa or Siri. They are ditching the screen-first and application-first approach. They behave like an interface for interacting with the apps on users' behalf. The device decides for the user, selects one or more apps to complete the task in the background, and only presents the results. For example, Siri starting a timer app or Alexa putting stuff in your Amazon basket. It's not entirely breaking news - people have been shouting at Siri or Alexa to turn on their lights at home for years now. But up until now, there were very few such usable use cases. To put it bluntly, Siri or Alexa is quite dumb and cannot understand anything but precisely phrased questions and requests and complete just the simplest tasks.

However, they are a small but essential step in a significant new direction - towards seamless integrations and unified experience, away from the siloed apps we use today. But only with the recent advent of generative AI the search for new interaction patterns really got off. Powered by the recent advancements in generative AI, it allows for much more robust, usable, and exciting interactions. Large language models, the backbone of today's AI tools, can understand so much more than Siri or Alexa of the past. We can design products built around truly functional AI for the first time in history. Just imagine a digital personal assistant that is actually useful and that can do things.

All these possibilities lead several companies to pursue new hardware form factors; to search for new bodies for the recently born generative AI. In the realm of AI-driven devices aiming to offer alternatives or complements to smartphones, the Rabbit R1 and the Humane AI Pin stand out for their innovative approaches to digital interaction. These devices are pioneering in integrating AI to simplify and enhance user experiences, each with its own set of features and functionalities that distinguish them from traditional smartphones and each other.

Humane AI Pin

AI Pin by Humane made headlines long before the official unveiling or shipping of a single unit to customers. It has generated considerable interest, especially among tech enthusiasts looking for the next big thing in personal AI devices. AI Pin is a screen-less (well, not entirely), square-shaped standalone wearable device that attaches to the wearer's clothing with a magnet. Equipped with a camera and various sensors, the AI Pin can scan the surrounding environment.

Designed as a digital personal assistant, it offers a range of functionalities through voice commands like reading messages, replying to them, or searching the web. With its camera, it can also see the surrounding environment and describe it back - e.g., recognizing the fridge's contents and suggesting to the user what she might cook for dinner. It also uses a laser projector to create a user interface on the user's palm, navigable through gestures and voice commands - although this feature seems to be very finicky, even on promo videos.

Rabbit R1

Tiny orange box Rabbit R1 is not a phone. But also not not a phone. The best description is probably a handheld device that can control your apps for you. My first thought when I saw this device for the first time was Couldn't this be an app? It just feels like Siri if she would be any good.

The hardware of R1 looks excellent. With its small rectangular body, roughly the size of half of the iPhone, bright orange color, 2.88-inch touchscreen, and cool physical gimmicks like a scroll wheel or rotating camera, it is something you just want to hold in your hand. The Teenage Engineering partnership is clearly visible here. So far, so good.

R1 runs on Rabbit OS, powered by a "Large Action Model" (LAM) designed to act as a universal controller for apps, aiming to streamline interactions between the user and various digital services. LAM is supposed to deliver on the promise of actually being a helpful personal assistant by learning how to operate any app and then doing it for the user. This is the most promising part of the whole Rabbit story. ChatGPT and other LLMs can generate texts or images, but R1 can actually do things because of its ability to learn the various apps.

Still destined to fail?

The emergence of devices like the Rabbit R1 and Humane AI Pin reflects a growing desire for smartphone alternatives that demand less of our time and attention while still providing powerful and intuitive digital interactions. Both devices are advertised as universal controllers for various apps or even smartphone replacements. The problem is that a pretty capable controller of various apps is already in almost every person's pocket - their smartphone. And for some use cases, like checking your account balance, you want more privacy than a loudspeaker clipped to your jacket.

Still, both devices bravely push the current boundaries and show what might be possible in the future. And I believe there's a much larger potential for smartphones to integrate AI more powerfully within their existing operating system - and then the leap towards a more universal app controller will be just an update away - not in a new device.

How can we encourage people to use something new? One way is to take an interaction that they are already familiar with and replicate it in a new context. The new product should be designed in a way that feels familiar so that users can feel comfortable with it. Successful designs must balance between offering new solutions and maintaining familiarity. Let's explore why and how this approach works.

People do not change much. Especially if you compare human evolution with the evolution of the technology that the same humans use every day. We are almost indistinguishable from people living in the middle ages, but we are wielding smartphones instead of swords. And even if we limit the evolution to the past few years, the technology has changed dramatically. But people, of course, have not. 10 usability heuristics by Jakob Nielsen from 1994 are still very valid in 2024. So, the safe way is not to wander too far from familiar grounds of traditional user interface elements. Getting people familiar with new interaction patterns is hard, and when new products overshoot with innovations, they often fail.

When a new technology takes a familiar and understandable shape, people tend to be more comfortable with it. Skeuomorphism is a term that describes taking something known from a physical world and creating its digital equivalent. It utilizes the principle of affordance - the average human has seen and used many buttons, so they anticipate that button-shaped digital objects can be pushed. The same principle was used when designers created digital equivalents of computer desktop, files, folders, or thrash can in early personal computers’ first graphical user interfaces. People can easily recognize what these digital images on the screen are used for because they know their real counterparts from the world around them. This familiarity dramatically helps with the adoption of the new technology.

Designers can help users adapt to new technologies by retaining most of the familiar interaction patterns and only changing some elements or contexts. The primary goal is to strike a balance between innovation and familiarity in interface design and to make the transition innovative, but not too disruptive.

But how do we utilize the principles of skeuomorphism in human-AI interactions? Those interactions are typically conversational - there's no physical button, thrash can, or folder we can use to create its digital equivalent. We need to look at how people communicate with each other and try to replicate the key principles in the conversations with AI. We need to make artificial intelligence tools more human. To anthropomorphize it. Anthropomorphism means the attribution of human traits to non-human entities. People have been doing this for ages, and apparently, it worked - think of any religion or mythology. The concept of anthropomorphism is not just a random creative idea but a strategic tool to enhance user interactions and experience. By infusing AI with human-like characteristics, we can bridge the gap between digital and human interactions, making technology more approachable, intuitive, and effective. Let's look at some strategies we can use in today's AI chat interface use cases.

Tone of conversation

Siri or Alexa are capable assistants to a certain extent, but can you really talk with them? To hold a proper, enjoyable conversation? Not really. This changed with the advent of the widespread use of modern Large Language Models (LLMs), which can make the conversation sound almost indistinguishable from a real person. And some tools like Replika do such a good job that some people are making friends with the AI avatars.

Voice modulation

Speaking of Siri, do you remember her first version? Or basically any other computer-generated voice? They all sounded flat and artificial. That’s why voice modulation in AI systems represents a significant step in humanizing technology. By utilizing voice modulation techniques, AI can deliver responses in various tones and nuances that closely mimic human speech patterns. This capability is particularly impactful in voice assistants, where the subtleties of tone can convey empathy, enthusiasm, or concern, mirroring human emotions. For instance, a voice assistant that can soothingly respond to a user's stressful situation or energetically share good news adds a new dimension to the interaction, making the experience feel more engaging and personal.

Role-playing

People typically specialize in their lives and careers. They're becoming doctors, engineers, architects, or any other imaginable profession. They play a role. And this role tells others what to expect from them. You don't go to a blacksmith to fix your teeth (well, at least not anymore). When you hurt yourself, you go to see the doctor - and expect him to do reasonably well based on the general perception of his role. The very same principle can be applied to AI tools to set expectations and build trust with the users. Assign AI a role it should play and fine-tune its tone of voice to sound accordingly. People are already using this strategy today, asking general-purpose AI chatbots like ChatGPT to assume a specific role and act like, e.g., a senior project manager when creating a project plan. Or Meta, with their try to create chatbots based on celebrities - so the users might interact with AI representations of someone they already know from the real world.

Learning and adaptation

When you currently use the ChatGPT, you start every conversation with a blank slate. The tool doesn't remember anything from the previous conversations. This can be particularly frustrating if you use it often for similar tasks and need to write the full instructions every single time. A significant step forward is an AI tool that can learn from user interactions and adapt over time, much like a human would in a similar role. This creates a sense of growth and development in the AI's behavior and makes the tool so much more usable in everyday tasks.

The future of anthropomorphic AI

Embracing anthropomorphism in AI represents a significant step towards human-centric technology. By making AI more humane, relatable, and engaging, we can utilize its potential to enhance people's daily lives, making interactions with technology more natural and enjoyable. Looking ahead, I believe the future of anthropomorphic AI is promising. We can expect more sophisticated and nuanced human-like interactions as AI technology advances. This evolution will make technology more user-friendly and open up new possibilities for AI applications in various fields, from education to entertainment and beyond.

Generative AI-powered tools are appearing more and more outside the initial experimental zone and finding their way to real business settings. They are evolving from "toys" and "gadgets" into the category of essential "tools". Tools need to be precise and reliable. A carpenter needs to have a reliable hammer or accurate saw. He shouldn’t question the hammer's ability to drive the nails into the wood. Similarly, in the business world, there's no time and place to doubt whether the calculator gave you the correct number. Businesses rely on correct numbers. The trustworthiness of these numbers is not just a convenience; it's a necessity.

Trust can be a tricky challenge with all this AI development going on. It's typically not a big deal when Midjourney creates an unexpected image or when ChatGPT misunderstands the prompt and suggests irrelevant ideas. With such creative tasks, users ask the generative AI tool to try again or adjust the prompt. The problem becomes very real when the business user asks the AI-powered tool to present some hard numbers - e.g., the number of products their company sold over the past year or the revenue composition across product categories. The result is about something other than being likable or not - it's about being true. Incorrect numbers presented with AI's infinite confidence to unaware users could result in significant business damage.

How can we create AI-powered tools that convey trust? Generative AI tools are built on large language models (LLMs) - these are black boxes from their very definition. They aren’t transparent, and from any point of view, that is not a good start for building trust.

We need to be as transparent as possible about how the AI tool came to its conclusion – about their “thought process”. Convey the message that the AI tool is crunching your numbers, not making them up. 

Be honest about the AI’s capabilities

Start with being honest and clear about what an AI system can do. Be sincere about its capabilities. Set the expectations about what the AI system is designed for. The field of AI is currently very dynamic and generates a ton of false information, misconceptions, or unreasonable fears. Therefore, users might come to your tool with prejudices or unrealistic expectations. Manage the expectations from the start so the users are not caught off guard. Clearly specify the focus of the AI system and what kind of output the user can expect.

Set the right expectations

Next, make clear how well the system can do what it can do. Users might have their expectations set from different tools, so they may not realize how often the AI system makes mistakes, even in the tasks it is designed for. Current generative AI systems often hallucinate and confidently claim half-truths or utterly false information as correct so it is important to remind users to check the results. AI models also like to lie and fabricate backstories to get approval from their users.

Make it clear that AI is crunching real numbers

The source of data is not as important (and downright impossible to tell) when generating a creative output like a joke, poem, or image. However, it becomes very important once the user starts to use the gen AI tool to search for real-world information.

When we move one step further into the realm of accurate business data, transparency about the data sources is the main building block of trust. With business use cases, it needs to be crystal clear that the AI tools are not making the information and numbers up, but they are crunching your company's real data and calculating the results. If you want users' trust, you need to explain each step and show how the AI tool got to the result. Again, it's about showing that it's not making them up. This layer of transparency allows users to actually trust the result by quickly checking where the numbers are coming from.

Ensure data privacy in business AI

When talking about business use cases, it's impossible not to mention the problem of data security and privacy. Companies building generative AI tools are not known for being particularly subtle about getting the training data for their models, so, understandably, business users are very cautious about their companies' data. One doesn’t need to search too hard to find one or two examples of such behavior. There, it must be clear that the AI tool is touching the company data to retrieve the desired results, and those data are not used for anything else – especially not for training the AI models.

Building users' trust in the AI tool is challenging and very easy to break in the same way as, as breaking trust between business partners, co-workers, or friends. A bad reputation is hard to fix, if not impossible. So always think twice about the choices that might betray users' trust in your AI-powered product. Trust is simply the essence of business AI tools, and without it, generative AI will stay in the realm of toys and creative companions.

Learn more

Together with my colleagues at GoodData, we are working hard to deliver AI to the hands of business intelligence users. If you would like to learn more, here’s a simple recipe for a serverless AI assistant. Are you interested in trying the latest business AI-powered data analytics tool from GoodData on your own? You can - just sign up for free for the GoodData Labs here.

Most AI applications today are either just a simple AI chat interface or the original application with the AI chat interface glued on top. Apparently, all it takes today is to take the chat window, slap it over any application, and we're done - now it's the time to put the AI-powered, AI-driven, or AI-whatever label on the company website. Profit!

One is almost dizzy from this inflation of chat interfaces. Of course, chat, conversational, or textual interfaces are valid and robust design concepts in specific use cases. Talking to other human beings online or a command line interface comes to mind, sure. But trying to squeeze all the commands into that tiny text field? No, please! We've been there - remember MS-DOS?

Author and designer Golden Krishna wrote a whole book around the statement that the best interface is no interface, and the engineers/designers of the current AI products apparently took notice. It's a valid concept but taken too far in the space of recent AI tools development. Mainly because the AI systems - in the same way as any other systems - have a certain level of complexity that cannot be designed away into the form of a simple chat interface.

As stated by Tesler's law, for any system, there is a certain amount of complexity that cannot be reduced. It implies three main takeaways:

1. The complexity needs to be assumed by either the system or the user.

2. As much as possible, the burden should be lifted from users.

3. We should not simplify the interface to the point of abstraction.

I argue most of today's AI systems are breaking this law by assuming most of the complexity burden to users. All the heavy lifting of controlling the application is left to users - the UI controls are gone, and all that remains is the chat interface. That requires unnecessary effort from users to remember various commands to control the results of generative AI.

We need to strike the balance between the chat interface and the traditional UI controls - not to design away so much of the interface that it's detrimental to user experience.

I think that the commands sent in the prompt to an AI system can be divided into two main categories. Let's look at generating images as an example, but the distinction works for other types of tools, too:

• Creative commands - what should be generated - the subject and its properties

• Technical commands - should it be artwork or photo, desired look, image aspect ratio, creative style, artist simulation, used colors, etc.

The distinction might be a little arbitrary, with a grey zone in the middle. But I still believe it serves a point applicable to the UX of such tools:

Technical commands should be lifted away from the textual prompt and user should be able to specify them with traditional UI elements like buttons, selectors, or sliders

These hybrid user interfaces were already mentioned by Jakob Nielsen in the article AI Is First New UI Paradigm in 60 Years: Future AI systems will likely have a hybrid user interface that combines elements of both intent-based and command-based interfaces while still retaining many GUI elements. I could not agree more - I strongly believe this is the way forward to allow AI capabilities to wider audiences.

Let's now look at how Adobe Firefly implements this hybrid interface. Firefly starts with a standard AI chat interface. It already contains animated suggestions of prompts together with the images in the background. These hints are great for overcoming the user's initial fear of an empty chatbox:

After the user enters the prompt, after a few seconds of processing, the following interface is shown:

The interface shows both the conversational interface for creative commands and the traditional UI for technical controls - this combination offers a wide range of possibilities for manipulating the image and creating different artistic styles without the need to type all the commands manually. The difference in the user interface and experience is striking when compared with other image-generating tools like Midjourney or DALL-E via ChatGPT:

With Firefly, Adobe did a great job with a hybrid user interface - it nicely combines creative and technical controls into one cohesive user interface, allowing even less experienced users to create a wide range of image styles. You might argue that the comparison is unfair since ChatGPT is a universal tool, and Firefly specializes in image generation. I think it's just a lazy solution that is hostile to the users. Since ChatGPT is invoking a specific image-generating model (DALL-E), it should also invoke image-specific contextual controls to accompany the bare chat interface. But that is a topic for a different article.

Generative AI applications are popping up everywhere. Every other company is thinking hard about how to use AI in their products. Some of them go for it, slap the AI chat interface on their current app, and hope for the best. Done; we can now put the AI-powered slogan on our website and steam ahead toward a bright future.

It's understandable from the business executive's point of view. Whoever stays behind these days will be left behind. The train of progress is not waiting for anyone. And since generative AI products already proved to increase productivity, it's hard not to jump on this hype train. Also, it is very tempting for engineers to add the most cutting-edge technology to their tech stack.

But hey, here we are, at the beginning of the year 2024, and this is the current state of the UX of AI. It barely exists.

However, I have never heard that apps pushed forward by the executives and engineers would be an excellent experience for the end users. But hey, here we are, at the beginning of the year 2024, and this is the current state of the UX of AI. It barely exists. End users, the actual people who should be using all those mighty generative AI applications, were left somewhere in the dust.

This situation results in technology-centric design—a complete turnaround from the user-centric design of the recent past. Users are not in the center anymore, far from it. It's the most obvious thing in the design world, but it's still worth reiterating - apps are built for the users. And if users cannot utilize the full power of the app, the app is probably not so well designed.

Let’s look at the mainstream generative AI tools. Their user experience design, or rather lack of it, is the most striking with Midjourney. The currently most capable image-generating tool is limited only to users willing to learn complicated text-based commands and post them to the chat of the dedicated Discord server. The history surely rhymes because this is MS-DOS and other command line tools all over again.

I’m not saying the command line interfaces are wrong - on the contrary. I think they’re brilliant and very efficient tools. But only in the hands of skilled users who know all the commands by heart and use the tools for their specific use cases. The learning curve of such interfaces is too steep for everyday users and their everyday tasks. And that loops us back to one of the fundamental promises of the whole AI story - to make the complicated technology accessible to regular users.

Let's say the effort vs. value curve of generative AI tools looks something like the shallow letter S. At the beginning, almost without any effort, generative AI tools provide quite some value to their users. It includes stuff like generating funny stuff, birthday present tips for grandparents, progressively crazy images, or random ideas to include in the next quarterly presentation. Simple and straightforward - a quick wins territory.

But most of the power of the generative AI tools is hidden behind the steep learning curve, undocumented features, or cryptic prompt parameters. The curve of required effort starts to rise quickly, and it is escaping the quick wins territory. Very soon, it crosses the critical point. Let's call it a point of prompt engineering. After that, the user enters the fluid now what? territory of Midjourney --parameters and ChatGPT prompts as long as short stories. Without consulting prompt hackers, searching the web, or spending significant time learning prompt writing, the value gained from the tool does not rise any further.

The role of UX designers in the age of AI is to push the curve to the right to allow more users to gain more value from the tool before hitting the point of prompt engineering. And to push it down to ease the steepness of the learning curve and allow less demanding entry for new users.

The role of UX designers in the age of AI is to push the curve right and down. Push it to the right to allow more users to gain more value from the tool before hitting the point of prompt engineering. Push it down to ease the steepness of the learning curve and allow less demanding entry for new users. In my opinion, this is the primary role of UX designers in today's era of UX of AI. It is the push against the technology-centered design and back toward the design focused on the actual end users and their needs.

But from the current state of UX of AI, it is evident that users are not the only victims of this technological AI race. I argue that UX designers were also left behind. Or we stayed behind. One way or the other, we need to get up to speed. Embrace the new AI UI paradigm - it's not going away anytime soon. Push for the user-centered design again. Start advocating more for the end users. Research and user-test every new feature. Push for better usability that would benefit users even if it means more effort on the development side. Talk to the engineers and business executives and persuade them that, at the end of the day, proper UX design is worth the effort and will benefit everyone. Let’s make 2024 the year the users were put back in the center.