All the interesting technology and cool functionality in the world is meaningless if what we build doesn’t solve the problems our users need solved. To do that, we need to create experiences that make it as simple as possible for users get the output they need from our AI features and leverage it in their work.

UX Pattern: Usage Guidance

One of the biggest mistakes we can make when developing AI features is assuming that users know how to use them. As mentioned in the first article of this series: we know how to do things like provide context, specify formatting requirements, break large tasks into smaller ones, and iterate toward better results when using AI—but our users often won’t.

When we place a blank text box in front of a user and tell them to “Ask AI,” we're actually asking them to do a lot of prework before they even get to their main task. So much, in fact, that it may actually create more work for them than just completing the task themselves.

They need to understand what kinds of problems the tool can solve, how specific they should be, what information the AI needs to succeed and how to recognize when a response needs refinement.

Rather than expecting this level of AI-literacy from our users, we can help them by providing examples, templates, suggested prompts and guided workflows that demonstrate what success looks like. And if there’s existing contextual information we can leverage without making the user input it all themselves, all the better.

UX Pattern: Action Buttons

What will your users be doing with the content your AI feature generates? If they run a search or analyze a spreadsheet, what do they do with the results? If they create an image, who are they showing it to? The action itself is just the beginning of the flow for our users, who then need to do something with what they’ve received.

By including action buttons, we can make it as easy as possible to them to leverage the output of our tools in their own work. If they’re not able to act on the content that was created, it’s never going to be of much realistic use to them. And if it’s not immediately clear what they can do with what we’ve created for them, then we need to show them with real-world examples.

Once they have an idea of what they want to do, action buttons can guide them to suggested steps that help make the most of what was generated. But an application that creates content a user isn’t sure how to use is nothing more than a novelty to be used once or twice and then ignored.

UX Pattern: External Integrations

If we want to take this one step further, we can build in direct integrations with their other most-used tools. For example, generating a new document in their word processing software from an AI writing draft, pushing new code to their linked repo, opening a new ticket in their tracking system with findings from a test. The simpler we make it to get information from our tool into the rest of their workflow, the more useful it will be to them.

Can Users Trust the AI Features in Your Software?

AI can generate content, write code, analyze data, automate tasks and empower our users to do incredible work—but only if they’re willing to try it. When everything our AI tools are doing is hidden behind the curtain, it makes users feel like things are happening without their input—which is hard, especially when many of them are already feeling some level of AI skepticism and hesitation.

If we create AI experiences that take away our users’ power, understanding and autonomy, then they’ll never be interested in using what we build because they’ll never feel truly comfortable engaging with it. By focusing on patterns that reinforce those UX priorities of trust, clarity, control, transparency and meaningful benefit, we can set guardrails around our AI features that help make our users feel safe.

The technology is here. The models are already good and they just keep getting better, faster and more efficient. That means that the differentiator for AI-powered software isn’t performance, anymore. It’s the quality of the experiences that we can build around them.

The line between design and development is blurring a little more every day: how users interact with a system, how much information they see, how much control they have and how we earn their trust are now questions that developers have to consider when building AI-powered software—whether your title includes “designer” or not. The technology may be incredible, but for it to be truly successful, users still need to be at the center of everything we build.

AI tools are strongest when they integrate into the rest of a user’s workflow—referencing internal documents, sending emails, making calendar appointments, drafting and sharing content with coworkers, so on and so forth.

However, most users won’t integrate what they can’t see and understand. If the AI applications we build are going to become part of their daily lives, users need transparency into exactly what they do, what data they have access to and what it will cost them (in both time and money).

The more transparent we can make these features, the less hesitation our users will have adopting them.

UX Pattern: Permissions

The concept of asking for user permissions is certainly not AI-specific, but the stakes can feel a lot higher when you’re asking users for permission to allow AI to act on their behalf.

We need to make it easy for users to see which applications we’ve allowed our tool to access and in what ways, keeping in mind that permissions are often more than just “yes” or “no.”

Can your agent just reference data from this database, or is it allowed to delete tables? Can it only read a user’s emails, or is it allowed to send from their address as well? Can it run scripts? Search local files? Each one of these actions requires direct user sign-off.

Permissions are also not a one-and-done situation. A user might feel comfortable allowing an action to happen once under their direct supervision, but don’t want to allow it permanently. They might give access to a specific folder, but not every folder. They might approve an action, but want to be notified each time it’s taken. Consider what gray zones might exist in your permission structure, and try to accommodate as many options as you can.

Another common sticking point with AI is data collection. Often, it can be helpful to save information from past interactions, but storing this kind of data requires real attention to user permission and data management.

If you want to create a system that can “remember” things, you also need to make sure it can “forget” as well—and that the user can not only see but has final say in what exactly what gets remembered. An ideal permissions flow will not only ask for a user’s approval in the moment, but also create a space where they can see the history of what they’ve given access to and when—and allow them to revoke that access or permission at any time.

UX Pattern: Estimates and Confirmation

This one is pretty simple, so we won’t spend too much time on it, but another crucial aspect of transparency is making sure users know exactly what they’re committing to when they approve an action request. In addition to approving the actual steps and plan (as we discussed earlier in the Trust post), they also need to know how much time it’s going to take and what it will cost them in money or tokens.

Even if we can’t specify an exact amount, providing rough estimates generally gives users enough information to work with—and to potentially revise their request if it’s going to exceed what they’re comfortable with.

UX Pattern: Solo Execution Indicator

Similarly to the marking that denotes which content was AI-generated, it’s also a good idea to have some kind of visual signal for when an AI tool is acting independently. If, for example, you’re going to allow an agent to take control of the user’s browser, then there needs to be a banner, sidebar, outline or some other kind of indication that the user is no longer driving the interaction.

Not only is this a good thing to do just for transparency—so the user understands the current state of the system—but also so they don’t unintentionally interrupt or confuse an ongoing process. It’s an especially important consideration for processes that you know will take an extended period of time, where the user may step away and come back without keeping track of everything that’s happened while they were gone.

Read next: AI UX Patterns to Show Meaningful User Benefit

AI tools are often framed as being a kind of personal assistant for the user, an intelligent junior coworker they can delegate tasks to. However, as anyone who’s ever delegated a task already knows … sometimes that means things won’t get done the way you would have done them.

When users are working with our AI tools, they need to know that they are still ultimately the ones in the driver’s seat. After all, there’s very little value in being able to assign the AI tasks if you can’t step in as you like to make adjustments, corrections and fixes yourself (just like you would with a real junior coworker).

UX Pattern: User Override

Sometimes, you know something is going to be wrong before the work is even complete. The sooner a user can step in to abort an obviously incorrect process, the better the experience will be all around: fewer wasted tokens, less wasted time and less repetitive work are all good things.

Wrong responses can (of course) be the result of AI hallucinations. But just as often they’re the fault of poor prompting, changing project specs or just straight up user error (typos, forgetting to include a requirement, etc.).

Realistically, the “why” isn’t really important here, other than to show just what a common scenario it is. What matters is how we empower users to handle it that matters.

It’s important for the user to be able to stop or override an AI action at any point—whether that’s during content generation, partway through an agentic workflow, when running code or something else entirely. If the user is unable to abort the process, then they’re not truly the ones in control—and that, frankly, isn’t acceptable.

One of the most reassuring things we can offer our users is a clear and prominent “emergency brake” they can slam to bring everything to a halt for any reason. That means it can’t be hidden in a menu somewhere or involving some specific command they have to remember (which they won’t in a high-stress moment).

We need to give them the equivalent of a big red button they can slam and make everything stop when they need.

UX Pattern: Version Control

Of course, once a user has stopped a process, we can probably guess what they’ll want to do next, right? Undo the incorrect work.

Even way before AI, Nielsen’s heuristics listed “safe exploration” as one of the core principles required for a good user experience. That means that users should be able to navigate back and forth, click and unclick things, and generally just kind of mess around in a piece of software without getting stuck or unintentionally making permanent changes. Sometimes a user will try something and decide they don’t like it or it didn’t do what they thought it would—and in those cases, we want to make it as easy as possible for them to roll back to an earlier state.

This kind of safety net was always valuable, but now that we’re dealing with non-deterministic output, having some type of version history is pretty much a non-negotiable.

Of course, the level of “version history” that’s required will differ based on the task. The Git style of version control that we’re used to as developers is probably more than you’ll need in a user-facing application. If this is a simple conversational interface, you may not need this at all; the user can just rephrase their question and try again when they don’t get the results they wanted.

If your AI tool is doing something more complex, such as creating and editing a document, then simple undo and redo buttons that allow users to move back and forth within the last 10 (or so) steps might be enough. If your app is facilitating truly advanced work, then it may be worth building in the mechanisms for checkpoints, save states or true advanced version control.

Consider what kind of tasks your user will be working on with your AI tool and how significantly each step forward is likely to change the existing content.

Ideally, this will also allow users the specificity to make targeted adjustments, rather than wiping out and replacing everything that happened in a given step. It’s common for AI-generated results to have a mix of quality in the output; users may want to keep some aspects while reverting others. The more control as we can give them over that creative process, the more enjoyable it will be to collaborate with our AI tools.

This is especially true now, as the cost of tokens is starting to tick up significantly. Having granular control over what gets reworked allows for more specific and productive iteration, rather than having to just say “try again” and effectively start over from scratch each time.

Read next: AI UX Patterns for User Transparency

Hand-in-hand with trust comes clarity. Clarity is one of the most important aspects of creating a good user experience, generally—and the stakes only get higher when we start incorporating AI.

Because so much of AI still feels like an unknown our users, we need to be as descriptive and straightforward as possible about what’s happening at any given time. The more insights we can give them about what our software is doing and what they can expect to happen next, the more comfortable they will feel engaging with our AI features.

I’ve noticed that there can be a kind of impulse to position AI to users as “magic,” not only in marketing but also within the software, itself. We don’t have to look any further than the prevalence of the AI sparkle icon to see example of that. However, while that might feel mysterious and cool, it’s not accurate.

Our users deserve clarity over dramatics. They want to know what’s going on and how a given output was created, and there’s no reason for us not to pull back that curtain wherever we can.

UX Pattern: Live Generation

One of the most obvious ways for us to do this is with streaming text or similar live generation of content. Not only is this is a great way to disguise the latency issue of AI generation (after all, nobody likes to watch a loading spinner), but it’s also a fantastic way to show the user what’s happening in real time.

If we make the user wait until an entire response is generated, there’s a non-zero chance that it won’t actually be what they wanted. However, if we start showing a partial response as it’s being generated, we give our users the chance to start assessing it immediately. That means they can start coming up with followup questions, adjustments or simply stopping the process entirely if it’s not returning what they expected.

This also engages the user as an active participant in the process, helping to prevent the XKCD “code compiling” experience of pressing a button and then walking away. You’ve probably experienced how much harder it is to complete a task if you’re constantly disengaging from the workflow. Even if you know that a process only takes a minute, if there’s not something to keep you there, you’ll start checking your emails, replying to Slack messages, scrolling social media … and just like that, a one-minute wait becomes a 10-minute detour, making it much harder to pick up where you left off. The more we can prevent this for our users, the more productive they can be with our tools.

UX Pattern: Thinking Aloud

Another thing that can help remove the wall between the AI and the user is having it “think out loud” as it processes a request. Similarly to live streaming, this also improves a user’s confidence level in the output because they’re able to kind of follow the breadcrumbs and have a deeper understanding of how a given conclusion was reached.

After all, we do this all the time when talking to other people! If we’re presenting an idea, we know that it’s helpful for us to talk through the rationale behind how we got there and why we think it’s the right choice. Explaining ourselves is a very natural part of human interaction that we’ve come to expect, and when we don’t see that mirrored in the systems we use it can feel frustrating—like something is being intentionally hidden from us.

Additionally, seeing the chain of thought process allows for better, more accurate revisions when the output wasn’t what they expected. If the user can understand all the steps that happened between points A and F, they can pinpoint where things went off the rails, allowing them to give more specific instructions or clarify ambiguous requests.

UX Pattern: Highlight Changes

Some patterns are easy to adjust from their previous non-AI usage into this context. Highlighting new content is one of those: it’s not groundbreaking, but when combined with everything else, it’s immensely helpful in helping users keep track of AI actions—especially when an agent is acting autonomously.

The basic idea is that when new content appears or something is updated, it gets specially marked for the user to draw their attention to it.

Sometimes that might mean literally moving their focus up or down the page to see what’s changed—like when new messages appear in an ongoing chat and the message history automatically scrolls down to display it.

But other times, it can just mean drawing the user’s eye back to a space they might not have been actively watching, even if that doesn’t include any literal movement on the page—like changing the color of revised text, putting a box or highlight around new material, or marking lines of code that are different.

Read next: AI UX Patterns for User Control

AI is a truly unique new technology: rapidly developing, and with so much potential to improve systems and software in ways that we couldn’t have even dreamed of just a few years ago.

However, along with all that potential is no small amount of risk. AI’s non-deterministic nature means that output can wildly range in quality, format, style and accuracy. On top of that, it requires entirely new types of interaction patterns to use. We’ve seen the emergence of new vocabulary, techniques and sometimes entire roles to address that need!

For those of us who live and breathe this technology every day, concepts like prompt engineering, hallucinations, retrieval-augmented generation and so much more have become a regular part of life. But for the vast majority of our users, that simply isn’t the case.

The Developer / User Gap

In any kind of technology, there’s a gap between the developer—who has, by nature, become the subject matter expert—and the user. The technical literacy of the average software engineer is always going to be higher than the average user of said software.

That’s where UX comes in. It’s how we bridge the gap between what we intended when we built the application and what the user actually … well, experiences. After all, it doesn’t actually matter what our software can do if our users hate using it so much that they avoid it at all costs.

Right now, AI has a serious UX problem. Our users are seeing AI features get added to basically everything right now—from their work software to their social media apps, right down to their computer and phone operating systems. But, as a wise technologist once said: “Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.”

We’re pushing users to adopt these new tools and features, but we’re not making it easy to do so. It’s common to see situations where a user is presented with a poorly designed AI feature they have only the barest idea how to use. Then, when they try it and it doesn’t do what they wanted or expected it to do, they feel annoyed, off-put and negative about AI, generally.

The more times users try an AI feature and get subpar results, the less likely they are to engage with it again in the future—which means that as the creators of these features and software, we only have so many chances to get this right before our users disengage and stop trying at all.

In my personal opinion, the knowledge gap between developer and user when it comes to AI is one of the widest I’ve ever seen. That makes it extremely hard for us to build AI-powered features that our users will actually get the full benefit from.

But, thankfully, this isn’t the first time we’ve had to introduce complex new technologies to our users. We have decades of user interface design history we can learn from!

Adapting Existing Patterns

For example: when Macintosh introduced their graphical user interface, it was—like AI is now—something very different and unfamiliar to their users. A large part of their success and reputation was built on their ability to create a user experience that met users where they were. They borrowed terminology and user flows from real life, included lots of icons and visual representations, and walked users through how to get the most out of their computers.

Over time, as the average user became more comfortable and literate in the space, the UX evolved with them and we start to see more technical terms and fewer abstractions. 

Look at the difference here between the Control Panels in Macintosh System 1 and System 6:

If you’d presented a System 1 user with the words “Rate of Insertion Point Blinking” or “RAM Cache,” it would have been meaningless to them. Similarly, we see the low and high volume icons are gone in System 6, along with the turtle and rabbit speed icons—that kind of more literal depiction isn’t needed anymore.

Right now, we’re probably somewhere around System 3 in this (now very extended) metaphor of introducing AI to users. We may not need the turtle and rabbit icons anymore, but we also can’t just assume they’ll sit down with our AI software as experts.

The good news is that (unlike the System 1 Macintosh UI) we’re not starting from scratch. Our users already have mental models about software usage that will carry over to what we’re building—they just won’t always map over exactly one-to-one.

That’s where we come in. As developers, it’s our role to leverage patterns users are already familiar with, combine them in new ways and introduce them to our users gradually in a way that doesn’t feel overwhelming. A good user experience will not only provide a user with the tools, but also guide them through how to use them.

For instance, let’s consider an AI chat interface. From a purely UI perspective, chatting with an LLM is almost—but not quite—like chatting with another user. We’ll be able to borrow some familiar patterns, like having the user’s chats show up on one side and the AI’s chats on the other, messages appearing above an input field with a send button, a scrollable message history and more. That gives our users a great jumping-off point as well as a lot of visual clues about how to start interacting with our AI chat.

However, the experience isn’t quite close enough that we can just lift an existing interface for direct messages and repurpose it wholesale—a chat interface that was built for two people won’t have the accommodations we need for things like adding reference sources, pausing or stopping an in-progress reply from the LLM, leveraging agentic tools or integrations, and more.

Those are the kinds of places where we need to adapt existing UX and UI patterns into something new. We have to be the bridge, helping our users transition into familiarity with AI experiences.

We can see the difference here. Compare this Copilot Research Agent new chat with the new Teams chat below:

Both have familiar aspects such as text boxes, the “plus” to attach files and so on, but the Teams chat assumes a much higher level of familiarity. It doesn’t spell out any of the iconography used, and we don’t see some of the elements intended to lower the barrier of entry (such as the examples, large text buttons or voice interaction options).

Can’t We Just AI-Generate This?

Before we really dive in, though, I think we have to address the elephant in the room: why not just have the AI create these solutions for us? Why do we have to be the ones who design and build these new patterns when we have technology that can generate interfaces for us now?

The problem with that is that an AI can only “create” things that already exist. It’s fantastic for looking at existing common patterns and replicating them—but (as discussed) the new patterns for AI interfaces just don’t exist yet. Or, at the very least, they’re still being rapidly developed and changing all the time as the technology advances.

There’s not a long history of standardized and familiar AI-related interfaces that can be referenced to solve this problem, so (at least for now) we have to solve this one on our own. Maybe that will change down the road—but for the time being, this is still a very human problem.

Additionally, as many folks (including our users) have begun to notice, the design an AI creates will be … well, a lot like every other design out there.

AI can reference and remix, but you’re not going to get brand new concepts from it. An AI-generated UI tends to look pretty darn average—and while that can be a good starting point, it’s not usually a good ending point. If you just need a quick landing page, it will probably do the trick. But since we’re dealing with a whole new interaction mode that needs more attention paid to the UX rather than less, it’s just not going to be enough to get us where we need to go at the quality level our users deserve.

The Five Categories of AI UX Priorities

So: if we’re going to build new patterns and new interfaces to help our users get the most value out of this technology, where do we start?

Well, like most things in design, it’s best to start with the user—specifically, the user’s problems. That means that when we’re thinking about building our AI features, we need to be thinking about what challenges our users have with AI and the user flows that will mitigate those issues as much as possible.

From the user research I’ve been doing and the users I’ve spoken to, I’ve grouped the main priorities into five categories:

1. Trust
2. Clarity
3. Control
4. Transparency
5. Meaningful Benefit

In this blog series, we’re going to discuss each of these in depth—understanding the problems our users have when using AI, and looking at some examples of patterns or techniques we can employ to address them. By addressing each of these, we can create AI experiences that support our users through the introduction of this new technology and empower them to use it to its fullest potential.

Read next: AI UX Patterns for User Trust

Wiring up an LLM endpoint takes an afternoon; the harder engineering problem is building a UI layer that can absorb the inherent unpredictability of AI without introducing layout thrashing, inconsistent interaction patterns or sprawl that a small team can't maintain.

That's the problem Icanpreneur solved with KendoReact.

“The hard part with AI is not just calling a model – it’s designing complex, trustworthy workflows around it. That’s where KendoReact helped a lot.”

Icanpreneur’s platform orchestrates guided, AI-assisted workflows that blend business logic, structured data and real-time feedback into a familiar, approachable experience. Users move through Lean Canvas modeling, validation flows and strategic planning steps with AI augmenting their thinking along the way. They’re now used not only by early-stage founders but also by accelerators, innovation hubs and product teams inside organizations such as Founder Institute, Campus X, Science Park Graz, ABLE Activator, Sofia Tech Park, Visa Innovation Program Europe and Telerik Academy’s Upskill Product Management program.

Raw AI output can be unpredictable. Without a stable, consistent UI foundation, that translates into friction and mistrust. The consistency, predictability and performance of KendoReact in the UI layer turned the output of Icanpreneur’s AI assistant, IVA, into something usable and trustworthy. For Icanpreneur’s six-person team, KendoReact was the infrastructure that made AI usable at scale.

Icanpreneur’s Architecture

At a high level, Icanpreneur’s platform is structured as a layered system that separates UI composition and user interaction, server / API management and LLM orchestration.

KendoReact is the core of the Icanpreneur UI layer, allowing them to guide users through complex multi-pane screens, support long-running workflows with consistent UI patterns and handle advanced multi-step journeys without overwhelm. Every major module (Lean Canvas, conversational interview console, go-to-market editor, persona builder) is composed from the same KendoReact primitive set, themed consistently and governed by the same layout contracts. That decision paid compounding dividends as the product scaled.

In an AI-first platform, it can be tempting to start thinking about the UI as set dressing; just a thin layer over the APIs to make things “look pretty” for the users. However, AI interaction patterns are still very new and unfamiliar to many users. A UI that naturally folds AI into the user experience can be a real differentiator in the competitive market.

“Founders in partner programs started telling us that the interview, insights and go-to-market flow ‘feels like one tool – simple and intuitive, not five stitched together.'”

AI technology is impressive but UI engineers are still the ones who translate that potential into true value for the user. In Icanpreneur’s case, they needed stable layout primitives, reliable form controls and high-performance data visualization components – all of which had to present AI output reliably (while responses were streaming, partial or evolving) without triggering unnecessary re-renders or layout shifts. KendoReact provided that and more, empowering the team to focus their effort on user experience, business logic and AI orchestration.

Composability as a Force Multiplier

One of the most important architectural decisions was treating KendoReact not as a collection of finished widgets or mere building blocks to be combined but as true UI infrastructure. KendoReact powers everything from research dashboards and conversational interview consoles to mini-CRMs and multi-step go-to-market editors.

Foundation pieces were combined to create higher-order workflows that guide users through their interactions with IVA. Rather than building custom UI for each flow, the team defined composable patterns built on KendoReact primitives. For example, the multi-step validation flow reused the same layout + navigation structure, AI feedback panels reused consistent container and typography patterns and interview summaries reused standardized layout and card structures. Because the Icanpreneur team didn’t need to design complex new interaction patterns for each additional feature, they were able to implement quickly and iterate fast – smoothly layering their AI workflows on top of KendoReact’s component system.

Consistent UX for Novel AI Workflows

For Icanpreneur users, this meant that they never had to open a page and feel unsure of where to go or what to do next – even though the AI-powered technology may be new, it leveraged familiar and consistent patterns to guide them through the experience.

“Because all the AI-driven experiences reuse the same KendoReact components as the rest of the app, they behave in a predictable way. Users don’t have to ‘learn' a new interface just because AI is involved – it feels like one coherent workspace.”

Design-to-Code Fidelity

With KendoReact, Icanpreneur designers and engineers worked from the same component language, which meant no translation layer between design and implementation, no pixel-chasing and no divergence between what's mocked and what ships. Designers also created a custom design system using the Kendo UI Figma Kits and the Progress Design System Kit, which greatly reduced the time needed to create mockups and new pages.

“Using the Kendo UI Figma Kits and a custom Kendo theme, we aligned design and development from day one. Most new features now start as a quick sketch in our KendoReact-based design system and turn into a working screen in days instead of weeks.”

Increased Development Speed

AI-assisted workflows evolve quickly: new steps get added, feedback formats change and validation criteria expand. Because KendoReact components are extensible and themeable, the Icanpreneur team could meet these challenges while still preserving UX consistency. As workflows grew, the UI layer remained adaptable; less time debugging or re-writing UI logic meant faster revision cycles and more shipped features.

“New workflow-style features (such as a new research flow or AI-assisted editor) now typically go from idea to shipped version in days instead of weeks, because we mostly compose existing KendoReact patterns instead of building UI from scratch.”

The UX of AI

Some of the biggest challenges in AI-first applications are handling uncertainty (usually in the form of partial / still evolving responses) and guiding users through new workflows. The Icanpreneur team leveraged KendoReact’s design tools to create UX patterns that integrate AI feedback into existing, structured UI flows, so users are never left wondering “what now?”.

One of the most unique features of Icanpreneur is their Synthetic Customer Interview feature, which allows their AI assistant, IVA, to answer questions as though it was a potential customer in their target market. Not all teams have easy access to customers to run interviews with, so this allows founders to “stress-test” their hypotheses quickly across multiple scenarios. That output helps them refine their questions and assumptions before talking to real people. Afterwards, IVA reviews all the data (across both real and synthetic customer interviews) to summarize, highlight patterns and extract quotes and evidence that can be leveraged in personas and further market research.

“When we designed IVA, the conversational interview console and the research workspace, we could prototype and ship quickly because we already had chat-style layouts built from existing KendoReact Layout and Form components, multi-step flows for things like research setup and go-to-market editors and reusable Panels, Drawers, Dialogs and Data Grids for displaying AI outputs, suggestions and insights aggregation”

Using KendoReact meant that not only could they leverage these familiar user patterns – but also that common AI concerns (such as slow, partial or unexpected responses) could be handled with UI structures and error responses that users already knew how to interact with.

Performance and Scalability

Icanpreneur workflows are complex, multi-stage journeys. Moving from idea to hypothesis, validating with AI or human-led interviews, identifying patterns and extracting valuable feedback, generating personas and finally creating landing pages or pitch decks – any one of these alone would be demanding but all together they offer a true development challenge. Each step builds upon the previous and the context must be preserved as the user moves between them. Without careful performance engineering, rendering and re-rendering these views would quickly degrade the user experience.

AI workflows can introduce frequent state updates as responses stream in or evolve - for example, when IVA synthesizes interview insights or drafts positioning. In poorly structured UIs, this can lead to layout thrashing or lag. However, these updates render inside structured, well-optimized KendoReact components, so the Icanpreneur UI remains stable.

As features accumulate, custom CSS and one-off component implementations are a common source of bundle bloat and regression risk. At Icanpreneur, new features and modules all plug into the same KendoReact UI system (rather than introducing new patterns and components). That allows even a small team to control UI sprawl and manage bundle growth. Custom CSS – a common pain point for fast-growing applications – is significantly reduced and centralized, because the UI is themed consistently. This kept initial load times reasonable even as the feature surface expanded.

“When we introduce new AI-driven experiences, they use the same KendoReact components, so we see far fewer UI regressions. That made it much easier to roll out new AI features without exploding our QA surface.”

That smaller, bounded QA surface meant faster turnaround and faster time to ship, while the lower complexity means that the small team was able to manage the expedited growth without being overwhelmed. New features that reuse existing KendoReact components inherit known-good behavior, so regression risk didn't scale with feature additions.

KendoReact’s components are designed for high-density, data-heavy enterprise applications; no reinvention (or re-optimization) was required even for complex components like grids, forms and dialogs. KendoReact reduced the need to solve hard performance problems manually, allowing Icanpreneur to access enterprise-level quality with a startup-size team.

Icanpreneur: Powered by KendoReact

Icanpreneur began as a structured way to guide founders from idea to product-market fit. Today it operates as a full AI co-founder, with IVA empowering entrepreneurs to ideate, validate and grow their companies as a trusted partner.

By treating the UI layer as infrastructure and building on KendoReact from day one, the team was able to:

• Scale complex, AI-driven workflows with consistency

• Ship new features rapidly without fragmenting UX

• Deliver a coherent experience across classic and AI-powered screens

For teams building AI-driven workflows, the UI layer is crucial: it's what determines whether AI output becomes a usable, trustworthy product or a source of friction. Icanpreneur's architecture is a case study in treating that layer seriously from day one. Or, as the Icanpreneur team said themselves:

“A six-person core team is able to maintain and evolve a fairly large, AI-first product (research, interviews, personas, positioning, landing pages, sales decks, etc.) without a separate “component team” or design system squad – KendoReact is that system for us.”

For teams building AI-driven applications with complex workflows, treating the UI layer as infrastructure can dramatically reduce friction as the product evolves. For Icanpreneur, KendoReact became that foundation: explore how KendoReact could become that foundation for your team, as well.

AI-driven applications introduce a new set of challenges for user experience design. Traditional web applications operate within predictable boundaries, where requests complete in a consistent and measurable way. AI features change that dynamic, with response times ranging from near-instant to long-running operations that can take minutes. Designing for that variability is no longer optional, it is a core part of building reliable AI-powered applications.

The challenge extends beyond implementation into perception. Users do not experience time objectively; they react to how it feels. A blank screen creates doubt, while visible progress keeps the experience grounded. When feedback aligns with the effort required, the interaction feels natural. When it does not, friction builds quickly. Thoughtful loading design addresses this gap by communicating progress, setting expectations and reinforcing the value of the task in motion.

This guide focuses on practical loading UI patterns for AI scenarios, organized by real-world wait times. Each pattern is implemented with Blazor and Progress Telerik UI components, keeping the discussion grounded in tools developers already use. The goal is simple: create loading experiences that do more than fill time, improving perceived performance and building confidence in the system behind the scenes.

Understanding AI Application Loading Patterns

AI applications introduce a different class of loading behavior. Traditional web requests are relatively predictable, but AI workloads are not. Inference, natural language processing and computer vision all introduce variability based on model complexity, input size and system load. As powerful as these capabilities are, they require a more deliberate approach to how progress is communicated.

Effective loading experiences center on managing expectations through clear, continuous feedback. Every loading state should communicate what is happening now, what has completed and what comes next, keeping users oriented as the system works. With this foundation in place, loading patterns can be tailored to specific wait times, keeping the experience responsive and understandable regardless of how long processing takes.

Near Instantaneous Responses (Less Than 1 Second)

For interactions under one second, traditional loading indicators often add more friction than value. Quick flashes of spinners or progress bars create a visual glitch that feels broken rather than helpful. Instead, the interface should respond immediately with subtle visual feedback that confirms the action without interrupting flow.

One exception stands out: when a fast action represents the final step in a longer workflow. In these cases, introducing a brief, intentional delay can create a sense of completion, giving users a moment to recognize the result of their effort before moving on.

AI Task Examples

AI tasks that typically complete in under one second include:

• Real-time text suggestions and autocomplete
• Simple sentiment analysis on short text
• Basic image classification with lightweight models
• Cached AI responses
• Rule-based chatbot responses
• Simple recommendation filtering

Blazor Implementation Strategy

Implementing instantaneous feedback in Blazor requires careful coordination between state changes and visual cues. The goal is to reflect user actions immediately while avoiding flicker from overly brief loading states. In practice, this often means enforcing a minimal display duration for indicators so that interactions feel smooth and intentional.

Try the A/B samples below by clicking the “Zoom and Enhance” buttons twice. The A sample should feel smoother on short intervals because of the intentional delay.

UX Strategy

Instant interactions benefit from confirmation rather than explanation. Subtle cues like button state changes, input highlighting or lightweight animations signal that the system has responded, keeping the experience fluid and uninterrupted. When these signals are consistent and immediate, users stay oriented without feeling like they are waiting.

Short Wait Times (1–3 Seconds)

Short waits call for lightweight, indeterminate indicators that acknowledge progress without interrupting flow. Simple spinners or skeleton screens work well because they provide immediate feedback while keeping the interface responsive. More elaborate animations tend to work against this, as users do not have enough time to process them and the interaction can feel slower than it is.

Skeleton screens are especially effective in AI scenarios because they establish structure upfront. By rendering a placeholder version of the final layout, the interface maintains continuity and gives users a clear sense of what is coming next as content is generated.

AI Task Examples

AI operations in the 1–3 second range include:

• Text generation for short responses
• Image enhancement or basic filtering
• Summarizing a document of moderate length
• Translation of short to medium text
• Basic data analysis and insights generation
• Voice-to-text conversion for brief audio

Blazor Implementation Strategy

Chat Progress and Thinking

The Telerik UI for Blazor Skeleton component provides a straightforward way to mirror final layouts while AI-generated content is loading and the agent is thinking.

Smart Paste Loading

The following demo shows a smart paste interaction that incorporates loading indicators to signal the process taking place. The Loading Container is displayed over the form fields being populated, while a button loader indicates the action is taking place once the button is clicked.

UX Strategy

Short waits benefit from clarity without added friction. Contextual messaging that reflects the task in progress, such as “Thinking” or “Generating recommendations,” helps users understand what is happening without slowing the experience down. When combined with progressive disclosure, where partial results are rendered as they become available, the interface stays active and responsive, reducing perceived wait time while making the system’s work visible.

Medium Wait Times (3–10 Seconds)

Users begin to question responsiveness, and a lack of visible progress quickly turns into doubt. Multi-agent workflows or agentic workflows with multiple indeterminate steps can be difficult to navigate. Agents can make requests to external tools that have asynchronous processes. While these processes run, it is important to report the activity in a manageable way without losing focus of the main content.

Blazor Implementation

Provide feedback for AI operations that expose measurable progress. The example below shows a chat process where the agent uses external tools. Loading indicators are exposed in a collapsible panel to allow the user to see the progress but also hide it when the details are no longer necessary.

UX Strategy

Medium waits benefit from a balance of clarity and momentum. Directional time estimates, even something as simple as “This may take about a minute,” help users decide whether to stay engaged or return later, while continuously moving progress indicators reinforce that the system is still working. When paired with contextual messaging that explains the current step or highlights what is being processed, the experience shifts from passive waiting to a guided interaction that keeps users oriented and informed.

Extended Wait Times (10+ Seconds)

Extended wait times require a different approach. Clear visibility into progress matters, but so does the freedom to move on without losing track of what is happening. Combining progress indicators with background processing patterns allows the system to stay transparent while keeping the rest of the application usable.

Percent-complete indicators play a central role here by giving users a sense of scale. Seeing measurable progress helps them judge how much work remains and whether it is worth continuing to wait. At the same time, providing cancel or abort options keeps users in control rather than locked into a long-running process.

Step-based indicators work especially well for multi-stage AI operations by breaking the process into clear, understandable phases. Even when exact timing is uncertain, each completed step provides direction and reinforces forward movement.

Blazor Implementation

The following example uses a grid format to display and manage agent activity. Each element displays important information about the task’s state. In addition, failure modes are included and made actionable from the interface. This type of UX is great for dashboard-like scenarios where users can launch agent workflows and return later to see the task completion status.

If the user may encounter a long and undetermined loading state, a looping indicator can be used to communicate the overall steps that are running in the background, without labeling exactly what stage the process is at now. This nondeterministic progress indicator displays a carousel of information while the user waits.

With agentic applications, long processes can give the impression of wasted time, even though a process that takes minutes for an agent may have taken a human hour to complete manually. This loading pattern reminds users of the work going on behind the scenes. While some consider this a “dark pattern” when used to obscure the process details, it can be quite useful when used correctly to share honest information about the value the process provides.

Extended waits benefit from a design that prioritizes flexibility and user control. Background task patterns, such as persistent status panels or drawers, allow users to continue working while keeping progress visible, reducing the friction of being forced to wait in place. When paired with notification systems that signal completion, the need to actively monitor progress is removed entirely, giving users confidence that the system will follow through.

Longer waits create space to surface meaningful insights, explain processing steps or provide guidance for improving future results. When these elements are combined effectively, the experience shifts from a blocking delay to a managed, transparent process that keeps users informed without interrupting their workflow.

Advanced Patterns for AI Applications

Contextual Loading Messages

AI applications benefit from contextual loading messages that explain current processing steps. Replace generic “Loading...” text with specific descriptions: “Analyzing image composition,” “Generating creative variations” or “Cross-referencing knowledge base.” These messages build user understanding of AI capabilities while setting realistic expectations for output quality.

Streaming and Incremental Results

Many modern AI applications support streaming responses, particularly for text generation. Implement progressive disclosure patterns that display AI outputs as they generate, reducing perceived wait time while demonstrating active processing. This approach works particularly well for conversational AI interfaces and content-generation tools.

Summary

Designing loading experiences for AI applications is no longer about handling delays. It is about shaping how users understand and interact with the system. When feedback aligns with the work being performed, users stay engaged and in control regardless of how long processing takes.

By matching loading strategies to expected wait times, developers can move beyond generic indicators and deliver feedback that is intentional and informative. From immediate visual confirmation to multi-stage progress tracking, each pattern helps make AI interactions feel predictable and responsive.

Blazor and Telerik UI components provide a practical foundation for implementing these patterns, enabling teams to build consistent loading experiences without introducing unnecessary complexity. The advantage comes from how these tools are applied, not just their availability.

As AI continues to shape modern applications, loading design becomes a defining part of the user experience. Applications that communicate clearly during processing will feel faster and more reliable, regardless of the work happening behind the scenes.

Get Started with These Examples

Use any of the Telerik UI for Blazor components shown above, plus the Blazor MCP servers free with the 30-day trial.

Try Now

This is the second post in a short series called Design Principles Unpacked.

In each article, I take a design principle we use every day and look at it a little closer. Not to explain the rule. But to unpack the wisdom behind it. Because I believe our professional knowledge and experience can be leveraged beyond work. The way we design and build software shapes how we navigate everyday life.

Many of the principles we use to design software exist for a reason. They help us make things work. They help us make things simple. And that doesn’t stop at software.

Let’s unpack the next one: hierarchy.

Hierarchy Is About Order, Not Value

When we talk about hierarchy, we usually hear words like control, authority or power. That’s where much of the resistance to the word comes from.

Hierarchy feels organizational. Political. Something that limits freedom instead of enabling it.

But in design, hierarchy isn’t about restricting. Just like alignment, hierarchy is about guiding. It’s about creating flow. Not what matters more. But what comes first.

At its core, hierarchy is simply an order of importance. It doesn’t say one thing is better than another. It says one thing needs focus first. That distinction matters.

Without hierarchy, everything feels equally important. And suddenly, even getting started becomes hard.

You see this immediately in interfaces. If headlines, actions and paragraphs all get the same attention, nothing stands out. Users don’t know where to look. They spend time and energy figuring out what matters, often focusing on things that aren’t important to them.

Hierarchy answers a simple question: What should the user pay attention to first?

Not because an element is more worthy. But because it helps the user decide whether it’s relevant.

A good UI doesn’t force you to read everything. It gives you orientation. It helps you navigate. That’s not control. That’s guiding.

Hierarchy as Filtering, Not Control

Let’s unpack this principle outside of design. This is where hierarchy takes on a different tone. It stops sounding like guidance and starts feeling like control.

Everything needs approval. Everything goes through the chain. Nothing moves without permission. But that’s not a hierarchy problem. That’s an execution problem.

Hierarchy is about purpose. What matters depends on the goal.

Good hierarchy filters. It reduces noise. It protects focus. It filters what needs attention now, so the next person in line doesn’t waste time sorting it out themselves. When something matters, it moves up. When it doesn’t, it waits.

Hierarchy in Leadership

I’ve seen this most clearly in my leadership roles.

In large organizations, there is constant noise. Requests. Opinions. Priorities. If all of that hits a team directly, focus disappears. Not because people aren’t capable, but because attention gets disrupted.

As a design leader, that was my responsibility. Pass on only what was important to our goals. Protect the team. Filter the noise. The role of hierarchy there isn’t control. It’s filtering.

Leaders at higher levels don’t do everything. They decide what deserves attention now and what can wait. That isn’t all about authority. It’s about enabling autonomy.

Closure

Hierarchy isn’t about value. It’s about purpose. An order of importance that allows work to flow. Clarity over control. Purpose over power. Autonomy over authority.

When hierarchy is clear, flow is clear. And when flow is clear, freedom increases.

Read next: Design Principles Unpacked, No. 3: Affordance

This is the first post in a short series called Design Principles Unpacked.

In each article, I take a design principle we use every day and look at it a little closer. Not to explain the rule. But to unpack the wisdom behind it. Because I believe our professional knowledge and experience can be leveraged beyond work. The way we design and build software shapes how we navigate everyday life.

Many of the principles we use to design software exist for a reason. They help us make things work. They help us make things simple. And that doesn’t stop at software.

Let’s unpack the first one: alignment.

Aligned to What?

Alignment only exists in relation to something else. It can be other elements. Other people. Other ideas. But most of the time, the actual reference is invisible.

The word align comes from a line. A guideline.

Without a guideline, left and right are just positions. Consistent, but static.

A guideline gives direction. It helps us make decisions. It shows us where we’re heading and why.

Take text alignment as a simple example. Text aligns to an invisible line on the left. That line is the reference. We set that guideline to create balance. To make reading easy. To avoid wasting cognitive energy. Because we read in a specific direction. Our eyes follow a learned path.

Those considerations are the real reference. The intent is to transfer written information efficiently. Alignment supports that intent. It improves perception. And help the message get through.

Intentional Misalignment

In visual design, there’s also optical alignment. Two elements can be perfectly aligned and still feel wrong.

That’s because there’s the perfect pixel. And then there’s perceived alignment. To truly align, you sometimes have to misalign. Deliberately.

The guideline defines the intent. But the execution requires adaptation.

Alignment isn’t about snapping things into place. It’s about staying oriented toward what matters.

The Composition of Reality

Reality isn’t static either. It’s a moving composition.

If alignment depends on fixed positions, you run into trouble. “Left only” works as long as the context stays the same.

But when you align to a guideline instead of a position, you can realign. You know what you’re orienting toward. You can adjust without losing direction. That’s why alignment works best when it’s relative, not absolute. Reality never stands still.

When you’re in an argument, you’re misalignment. Not because one of you is wrong, but because you’re focused on positions. Look past left and right. Find the invisible guideline underneath.

Aligning doesn’t mean watering down your convictions. It means recognizing the line you use.

Conclusion

The real skill isn’t knowing where to place things. It’s learning to recognize the guideline you’re aligning to. And choosing your position with intent.

When you zoom out, alignment becomes more than a principle. It becomes a way of positioning yourself on purpose.

Your position will change. Because reality happens.

But the line you align to? That’s what makes it by design.

Next post: Design Principles Unpacked, No. 2 Hierarchy

The landscape of web design can change dramatically from year to year. Not just because of trendy UI styles or features either. The world is changing fast and, with it, our users. As a result, their needs, desires and preferences when interacting with brands evolves over the years.

To keep pace with everything going on, web designers need to seek out opportunities for education. Reading blogs and books, listening to podcasts and following thought leaders on social media can be helpful. In many cases, though, this kind of content only covers the tip of the iceberg.

For a more comprehensive education and update on what’s happening, industry conferences can be valuable resources.

Every conference is different in terms of theme, availability (in person and online), cost and content. If you’re interested in attending a conference or two this year, keep reading to learn more about what’s available.

7 Upcoming Conferences for Web Designers

One of the nice things about web design conferences is that they’re held throughout the year. Some of them even offer virtual attendance options (if they’re not fully virtual to begin with). So if you miss one, there’s always another one down the road you can attend.

Here’s what you can expect at the following conferences for designers:

Adobe MAX

Location:

• In-person: Miami Beach Convention Center in Miami, FL
• Online

Dates:

• November 8-9, 2026 (Preconference)
• November 10-12, 2026 (Conference)
• November 10-11, 2026 (Online event)

What to expect:
Adobe MAX offers both an in-person and online annual event for designers, developers and creatives of all levels.

More than 150 sessions take place during this event. Sessions are broken up into different tracks, and include:

• 3D
• Branding
• Creativity and marketing for business
• Generative AI
• Graphic design
• Illustration
• Social media marketing
• Audio, motion and video

What’s nice about this conference is that each session will be assigned a technical level. This way, you can choose sessions that align with your interests and level of experience.

Now, if you plan to attend the in-person conference, you’ll have access to keynote speeches, Adobe Labs sneak peeks, 60-minute luminary sessions and creativity super sessions. After the conference, you’ll also be able to watch screen capture and audio recordings of any events you missed.

If you’d prefer to attend online, the programming is slightly different. Online Adobe Live Sessions will be 30 to 60 minutes and give you access to First Takes and Meet the Speaker sessions where you’ll learn more about Adobe products. Online presentations will only be available as replays and will last between 15 to 30 minutes.

Figma Config

Location:

• In-person: Moscone Center in San Francisco, CA
• Online

Dates:

• June 23-25, 2026

What to expect:
Figma Config is an annual conference for anyone involved in the development of products—designers, developers, marketers, product managers, etc. While some of the sessions revolve around Figma products and features, there are others that focus on the present and future of product design.

The sessions fall under the following themes:

• Strategy
• Process
• Craft
• Design systems

Although the schedule isn’t available yet, you’ll find highlights from 2025 Figma Conf from last year. These keynotes and sessions dig into topics like redesigning the computer mouse, collaborative brand design and creating interactive animations.

If you’re interested in watching the virtual conference, it’s free. You just won’t be able to watch the sessions in real time. The keynote sessions will go up on YouTube the day of and the breakout sessions will appear on YouTube once the conference is over.

FITC

Location:

• In-person: The Great Hall in Toronto, Canada
• Online

Dates:

• April 27-28, 2026

What to expect:
FITC stands for “Future. Innovation. Technology. Creativity.” This two-day conference is celebrating its 25th anniversary this year. Similar to the other conferences on this list, there will be round table discussions and various session tracks to attend.

One of the biggest differences between this event and the others is its theme:

“This year, FITC Toronto explores the theme of rebirth. In a world moving too fast and overwhelmed by AI and shiny new tools, we want to pause, reflect, and bring back the concepts that inspired us as artists. We want to pay homage to our creative journey, appreciate the small foundational things we learned along the way, and celebrate the essence of our industry.”

If this is something that resonates with you, you have two ways of attending.

In-person attendees get full access to all of the presentations, can take part in the Q&A and are able to attend evening events. They’ll also get six months of online access to the main room sessions.

If you want to attend online and for a discounted rate, you’ll be able to do so in real time. You’ll also get six months’ access to the replays after the event.

SXSW Innovation Conference

Location:

• Austin

Dates:

• March 12-18, 2026

What to expect:
South by Southwest (SXSW) is known for many things. Not only is it the host of popular Music, Comedy and Film & TV Conferences, it concurrently runs an Innovation Conference in March of every year. This is the one you’ll want to pay the most attention to as a web designer.

The Innovation conference has a variety of tracks that may be right up your alley, like Brand & Marketing, Design and Tech & AI. You may also find some interesting content in these tracks:

• Creator Economy
• Startups
• Sports & Gaming
• Workplace
• Health

While AI is going to be talked about a bit, you’ll find other interesting subject matter covered at the conference, like “Meet Gen Alpha,” “10 Truths About Technology That Are Shaping Your Life” and “You Can’t Create Cultural Relevance Without Community.”

This conference is only available to attend in-person, but you do have options. You can buy a Platinum badge for access to all the conferences, one strictly for Innovation, or you can mix and match based on your interests.

UXDX

Location:

• In-person: New York or Berlin
• Online

Dates:

• May 11-13, 2026 (USA)
• May 27-29, 2026 (EMEA)

What to expect:
If you’re a UX designer or researcher, then UXDX may be a worthwhile conference to attend. Two conferences are held in May—one in the U.S. and one in Germany. While the content is similar, it’s not identical. So, be sure to check out the agendas for each conference to find the one that interests you most.

Another option is to attend the conferences online. You’ll pay a discounted rate, but only get access to 20 talks instead of the 30 scheduled.

Unlike some of the larger design conferences, there aren’t separate tracks. This conference is solely dedicated to helping product teams deliver better results. So, you’ll find sessions like the following:

• “Shipping Faster With React Server Components”
• “Are We Designing for Humans or for Agents?”
• “Engineering Seamless Journeys Across Physical and Digital Touchpoints”
• “Closing the Design–Engineering Gap (for Real)”
• “Building Inclusion Into Our Design System And Delivery Process”

The sessions might not be as flashy as other conferences, but they’re meant to be actionable and empowering for UX pros.

Web Summit

Location:

• Lisbon, Portugal

Dates:

• November 9-12, 2026

What to expect:
Information isn’t yet available for Web Summit’s 2026 conference. However, this is what we do know about this annual event:

There are 20 tracks to choose from, which include:

• AI Summit
• Commerce Summit
• Creative Summit
• Developer Summit
• Fintech Summit
• Marketing Summit
• SaaS Summit

There are a lot of sessions going on at the same time, so you’ll want to do some planning ahead of time to make sure you catch the sessions that are most important to you.

Also, don’t forget to look into the meetups available throughout the four-day summit. You’ll find them for all kinds of groups, like Robotics Geeks, Spanish CEOs, CleanTech, Women in Tech and Neurodiverse Folks. These are a great way to fill the gaps in your schedule (if you have any) while enjoying some networking.

World Usability Conference

Location:

• In-person: Graz, Austria

Dates:

• October 13-15, 2026

What to expect:
The World Usability Conference is an in-person-only event that takes place over three days in October. Attendees can choose to buy tickets for one day, for the conference or for the conference plus workshops. While there’s no online counterpart, attendees get access to the recordings after the event.

This conference is all about UX strategy and management. During the sessions and workshops, you’ll get a chance to learn about common challenges in UX research and design, and how experts are navigating their way around them.

Tracks include:

• Enterprise UX
• Future UX
• Human UX
• UX Strategy
• Accessibility & Inclusion
• UX Research
• UX Management
• Leadership
• AI & UX

If you plan on buying a one-day pass, make sure to look up which tracks are available on each day. The conference organizers do a good job placing related topics together so that you can realistically get the information most relevant to you and your role in a single day.

Wrapping Up

One of the nice things about having so many conferences to choose from is that you can pick and choose the ones that are best for you.

Do you want to attend online, watch the replay or join in person?

Do you want to go for one day or the whole thing?

Are you interested in the talks or would you find it beneficial to attend the workshops, networking events and other programming?

Also, with most of these conferences planned well in advance, most of them offer special discounted rates for early birds. So, once you decide which ones you want to attend, there are budget-friendly ticket options available.

At the end of the day, there’s something for everyone. It’s just a matter of finding one with the program that interests you most, that fits your budget and that works with your schedule.

Teams are often obsessed with the final result.

But progress isn’t only found in the finish—it happens in the steps between. When we visualize those steps, the incomplete design becomes a powerful tool.

The Illusion of Completeness

When something is complete, it looks done. It suggests certainty. It feels like quality.

But in product development, “final” is an illusion. Just because the tasks are done doesn’t automatically mean the product is good. Dragging tickets to the next column can feel like progress but might hide a serious flaw.

I was building a small LEGO digger with my daughter the other day. It was interesting to see how she was more focused on following the steps correctly than fast-forwarding to a functioning digger.

The instructions were detailed. We used the mobile app with 3D models and animations. You trust the makers that every step is there for a reason. Together with IKEA furniture, it’s one of the few manuals I actually read—and for good reason.

There’s no room for guessing. It’s designed to be assembled in a certain way. Every step is illustrated clearly, and once in a while you get a little overview of your progress.

It’s simplified with micro-success. It’s continuous completeness. The final result is the reward.

The Missing Middle

Most teams describe what should happen at the start and verify what happened at the end. But the middle? It’s often hidden.

The result is rework, misalignment and late feedback.

The solution isn’t more documentation—it’s more visibility.

Wireframes, low-fidelity mocks or prototypes can be reverse-designed. From the current state to the desired state, you can show the progression.

Take a common case: An admin console where you manage access entitlements. The current version has a simple form: email, roles, save.

Now the team wants to expand its features:

• Users can get access by adding them to a group (dropdown)
• And generate an access control report for documentation (button)

All those additions lead to a new “final” state.

But each feature introduces its own interface and backend changes. To design this well, you can accompany each user story with a lightweight wireframe or diagram showing how the interface or system evolves—from the simple form to the new version.

This illustration is very basic. So, yes, it might feel like overkill. But all I did was copy the end state and hide the report button.

That might look trivial, but I’ve seen in real projects that this kind of visibility works. It removes unnecessary guessing. It’s childproof—like LEGO.

And it doesn’t take a lot of time to produce—just hiding a few elements and sharing them.

The result is clarity about progress.

Closure

Progress isn’t all about the finish. It’s made in the steps between.

When you visualize those steps intentionally, you don’t just show progress—you design for it.

Don’t just design the result. Design the progress.

Tabs have been around for decades and I haven’t seen complex enterprise software that doesn’t use them.

In all my years designing enterprise apps, two components have proven to be either the strongest asset or the weakest link: tables and tabs.

I already wrote about tables in my post on why you can’t beat the spreadsheet. Now it’s time to take a look at tabs.

The Friendly Developer’s Shortcut

If you’ve ever built enterprise software, you know that tabs are the default. They’re easy to implement. Nest items in code, separate them in the UI. Simple.

Back in the day, developers were also the designers. Tabs were the easiest way to bring order to complex screens. They stuck because they worked.

Also, much of software design simply mimicked the operating system. It’s no surprise enterprise apps followed Microsoft’s example.

Think of the old Windows settings dialog: a tiny screen packed with tabs.

That pattern became the blueprint for squeezing dozens of options into limited space.

Making use of every pixel was considered an achievement. Mobile-first design? Not even a thing.

The Untabbed Truth

The truth is, you’ll use tabs at some point. They’re too common to ignore. They turbocharge the experience, used well. But there are pros and cons to using them.

Navigation

• Pro: Easy to scan and move between categories
• Con: Too many tabs make scanning hard and moving slow

Disclosure

• Pro: Good for hiding lots of options
• Con: Important info or actions can get lost

Structure

• Pro: Clear structure and focus when used well
• Con: Nested tabs multiply confusion

Switching Tabs: Alternatives

Tabs aren’t the only way to organize complexity. Sometimes other components do the job better.

Accordions

• Pro: Great for progressive disclosure—show one thing at a time
• Con: Expand too many and you’re back to scrolling forever

Panels

• Pro: Easy to read, even with many items
• Con: Take more screen space and clutter the screen fast

Steppers

• Pro: Perfect when groups are steps in a process
• Con: Breaks down if users need to jump around or skip steps

Developer-Friendly, User-Centered

Tabs still have a place. They’re familiar and fast to build and can structure complexity. But they can also turn into a bottleneck—for both users and developers.

User Experience

• Pro: Clear structure and focus when used well
• Con: Hidden content or clumsy navigation slows everyone down

Development

• Pro: Quick to implement, easy to drop in
• Con: Custom solutions require more work to handle states and navigation

Code

• Pro: UI toolkits like Progress Kendo UI libraries give you accessible, tested tab components out of the box
• Con: Writing custom code adds complexity and risks breaking essentials like accessibility

Instead of reinventing tabs, lean on a toolkit that handles the heavy lifting. If you need an alternative, the toolkit makes it easy to switch. That way you can focus on the one thing that matters most: delivering a great user experience.

So tabs are definitely not a taboo—just handle them with care. Use them well, and with a toolkit like Kendo UI, you’re turbocharged.

The Kendo UI component libraries come with a free trial. Give them a shot today!

Try Now

Last year, we started really exploring the designer-developer relationship: from design systems, brainstorming, prototyping and user testing through the handoff, creation and launch process. Where are things working well? Why do we hit blockers? And why can’t developers understand the difference between cobalt and cerulean? (Just kidding about that last one … mostly).

We hit the streets conferences with a whiteboard and a ton of sticky notes and talked to hundreds of designers and developers in-person about their experiences.

Then, we broadened the scope and launched The State of Designer Developer Collaboration Survey, so we could hear from designers and developers all around the world! What we found was super interesting—but no spoilers: Go check out the results and see for yourself!

Now, a year has passed—and what an eventful year it’s been! The growth of generative AI has disrupted our workflows and processes in ways we couldn’t have imagined. Last year, we had a token few questions about AI, and many of our respondents were feeling hesitant about incorporating it into their work. This year, we’ve expanded to a whole section on AI—and I suspect that the responses will be quite different!

There’s only one way to find out for sure, though. Take The State of Designer-Developer Collaboration 2025 Survey: Workflows, Trends and AI.

We want to hear from you! Have things changed in your day-to-day work? Are you a designer who’s vibe-coding more interactive prototypes? A developer who’s asking ChatGPT for color scheme ideas? Have you been over- or underwhelmed by all the new AI features popping up in your tools? Or maybe nothing has changed for you, and you’re still keeping a cautious eye on this whole “AI” thing before diving in?

No matter what you’re experience is, we’re curious to hear about it. We’ll bundle up all the results into a meticulously detailed and (of course) beautifully designed report, and you’ll be the first to know.

Take The Survey

In a world where most of our lives play out online, web accessibility shouldn’t be treated as an afterthought. Designing with inclusivity in mind is no longer optional; it’s essential. Just like a chair needs four sturdy legs to be safe for everyone, digital experiences need to be built with all users in mind.

But when the platform in question is educational, the stakes are even higher. These platforms serve a diverse range of learners—some with visual, auditory, motor or cognitive impairments, and face stricter accessibility requirements than general websites.

That’s why Resolute was proud to partner with a U.S.-based company providing online training tools for frontline employees. The platform had recently been acquired by a leading provider of online compliance and workforce training, further raising the bar for performance, accessibility and scalability. The goal: build a more functional, accessible and scalable web experience.

When Design Slows You Down

The project started with a familiar pain point: fragmentation. The client’s design ecosystem was spread across multiple sources:

• An internal Figma library shaped by years of brand tweaks
• A partially customized theme inside Progress ThemeBuilder
• A live site with Progress Kendo UI components that didn’t always align with the designs

This led to confusion, delays and inconsistencies, especially around accessibility. Developers struggled to map designs to actual components. Theming was brittle. And certain UI patterns weren’t usable for people relying on keyboard navigation or assistive technologies.

Resolute was brought in to clean it up, streamline the workflow and help the client move toward a more compliant and scalable solution.

Fixing the Foundation: ThemeBuilder in Action

Our UX/UI team began by auditing the client’s existing design system. They worked closely with their internal team to unify the visual language and migrate it into Progress ThemeBuilder, which served as the central source of truth for styling and theming moving forward.

ThemeBuilder wasn’t just a convenience; it helped enforce consistency in design tokens like colors, borders and spacing, while also helping to align with accessibility best practices.

The UX/UI team’s work included:

• Consolidating redundant button and form variations
• Fixing visual issues with contrast, spacing and typography
• Helping the design team understand how to use ThemeBuilder effectively to support long-term accessibility

From Visuals to Code: Accessibility in the Build

Once the design foundation was solid, our frontend team began implementing the new UI in code. Over several months, the platform’s frontend was rebuilt with accessibility as a core requirement, focusing not just on how it looked, but how it worked for every user.

This wasn’t just about good UX; it was also about meeting real compliance needs. Since the platform serves a broad user base in the U.S., including educational and government-affiliated organizations, several legal standards apply, including:

• ADA (Americans with Disabilities Act): Particularly Title III, which applies to educational institutions and commercial websites
• Section 508 of the Rehabilitation Act: For platforms receiving federal funding or working with government entities

To meet these requirements, we aligned the build with WCAG 2.1 Level AA guidelines developed by the W3C (World Wide Web Consortium), currently the most widely used benchmark for web accessibility in the U.S.

What that looked like in code:

• Every interactive element was accessible via keyboard navigation (tab, arrows, etc.).
• Clear, visible focus states were implemented for all buttons, links and forms.
• We structured the app using semantic HTML and applied ARIA roles for assistive tech (e.g., <button>, <nav>, <form>). Yet, we applied ARIA roles only when necessary for custom components or non-semantic elements, avoiding over-reliance on ARIA. It’s crucial to use ARIA only when native HTML elements can’t provide the required functionality.
• For use cases beyond the default configurations of Kendo UI or ThemeBuilder, we wrote custom HTML overrides.
• Duplicate labels or screen reader confusion were avoided using attributes like aria-hidden="true" where needed.

Testing was both automated and manual. Tools like axe DevTools, WAVE and ChromeVox helped flag contrast issues, label duplication and navigation traps. But human testing mattered just as much. Therefore, a touchscreen laptop was used to simulate real user scenarios, check responsiveness and validate how elements behaved across screen sizes and input types.

When Customization Adds Complexity

Telerik ThemeBuilder and Kendo UI offer strong accessibility features, but when components are heavily customized, unexpected issues can appear. Resolute helped the client troubleshoot several edge cases:

• Buttons built without the base component didn’t render properly
• Some forms displayed labels twice to screen readers (e.g., “Username Username”)
• Blazor components lacked alt-text bindings, requiring a workaround

None of these problems were dealbreakers, but they showed how expertise matters. Without frontend developers who understand both the framework and accessibility requirements, these issues could have gone unnoticed.

Accessibility = Structure + Semantics + SEO

There’s another benefit to building with accessibility in mind: better search engine optimization (SEO). Many of the same practices that support users with disabilities, like using semantic HTML, a well-structured HTML DOM (Document Object Model) and meaningful headings, also help search engines understand and rank your content.

The frontend implementation in this case included:

• One <h1> per page, with clean heading hierarchies for structure like <h2> for sections and <h3> inside components
• Alt-text for all meaningful images
• Descriptive link text and accessible navigation

The result? A platform that’s easier to use, more discoverable and legally compliant.

Knowledge Transfer Matters

Resolute’s role expanded beyond design and development work. We trained the client’s internal team to maintain and build on the system with accessibility in mind. That included:

• Documenting all accessibility decisions and techniques used
• Providing reusable design patterns in ThemeBuilder
• Running training sessions on WCAG basics and development workflow tips

Accessibility isn’t something you do once. It’s a practice. So, we made sure the team could carry that forward.

Final Thoughts

Accessibility is a shared responsibility—across design, development and leadership. Our client understood that, and, with the right tools and support, made serious progress toward a platform that works for everyone.

Progress ThemeBuilder helped streamline and standardize the design-to-code process. Resolute helped connect the dots by aligning compliance, usability and long-term scalability.

Learn more about how Resolute can help address usability issues, starting with the UX Assessment.

Interaction design is a huge discipline that prioritizes how users engage with digital interfaces.

One goal of interaction design is to capture and direct visitor attention. We can achieve this with animations, transition effects, as well as motion-based designs and media.

Another goal of interaction design is to engage users to get them to click and convert. There are a multitude of components we might want users to click on throughout their experience. For example:

• Buttons
• Links
• Menus
• Videos
• Forms
• Popups
• Chatbots
• Search forms

What we want to specifically focus on today are the buttons and links that drive our users deeper into their journey and closer to conversion. We’ll look at five best practices when designing these key interaction points.

5 Best Practices When Adding Buttons and Links to Your Site

Links and buttons do a lot of work for us, strategically guiding users from one page in the user journey to the next. So that we don’t waste their time or ours, we need to be intentional with how we design these click interactions.

Here are some tips that will help with this:

1. Put Thought into the Design

Here are some questions to consider when designing your clickable components:

Do your buttons look like buttons? This could be in terms of shape, shading/fill or depth.

For example, here’s a screenshot from the Forward Financing homepage:

There are three buttons visible:

• “Apply for Financing” in the header
• “Learn More” in the hero section
• “How can we help you today?” in the bottom-right corner

The two solid buttons in green stick out the most and are clearly buttons. The ghost button in the bottom-right corner isn’t as prominent, but it does have a button-like shape, which may convince visitors to click it.

Are your links easy to spot among non-linked text? Don’t just think about this from a color-contrast perspective. For instance, will readers with vision impairments struggle to make them out?

Here’s a close-up on a blog post from Ramsey Solutions:

There are three hyperlinks that stick out from the surrounding text. It’s not just because they’re in blue font as opposed to black like the rest of the blog. It’s because they’re underlined.

The underline is key as it allows users with visual impairments to be able to detect the links visually without having to notice the color change.

Do these clickable elements fit with your color palette? This goes for both the active and hover state.

Does the click feedback fit with the overall vibe of your site? For instance, do some animations or transition effects feel disruptive or do they flow with the rest of your brand vibe?

For these last two questions, I’m going to use Making Sense of Cents as my example.

To start, they’ve done a good job of committing to a uniform style for the link color transformation. Upon hover, the black text turns to orange.

The main problem I see is with the blocks at the top of the homepage and how they react to hover/touch. The wiggle animation feels out of place when compared to the other interactions on the page. For the most part, their other button and link interactions feel very calm. However, these blocks create tension.

So, this is the kind of thing to think about if you decide to imbue your buttons with animated effects.

2. Provide Hover Feedback

Designing buttons and links to look like clickable elements is crucial. But so is the follow through (more so for buttons than text links).

There are a couple of things we’d want to see happen when someone hovers over a button.

First, the cursor should change from an arrow to pointer icon.

Second, the button’s appearance should change. If it’s a color change, the contrast needs to be significant enough where someone who can’t interpret the colors can still tell that something changed.

On the Chase homepage, for example, we only see one button change in its hover state—the “See details” button in the hero section. The only thing that changes is the background color from light blue to dark blue.

This isn’t going to provide users with an accessible interactive experience. Ideally, we want every button to provide clear feedback when someone hovers over it.

Let’s contrast this with what we see on the Pennie website:

This website’s first button does a similar color change effect, from a lighter blue to a dark blue. However, the buttons also elongate and an arrow appears when someone hovers over them. We see a similar effect happen over the accordion tabs in the section just below the fold.

Not every button needs to offer feedback in the form of an icon. However, subtle animation effects like expanding and shrinking can help give users extra confidence that the buttons are indeed buttons and will respond to their touch.

3. Be Specific and Clear with Labeling

The appearance of our buttons and links will certainly help visitors recognize where clickable components are in our interfaces. In order to give them an extra boost of confidence that a click will be worth their time, take care with how you label the buttons.

In general, we want to avoid vague wording like “click this,” “go here” and “this page.” “Read more” and “learn more” are in a bit of a gray area.

Here’s an example from the PEAK6 website where we see some “learn more” links:

Of the 12 primary links on this homepage, nine of them say “learn more.” Most of them follow a description of one of PEAK6’s companies.

Now, given the context of these particular buttons in the screenshot, “learn more” makes sense. However, there are ways to get around labeling your buttons with vague and repetitive phrases like these—especially when you have so many of them on a single page.

Here’s a look at how Octus handles a similar type of content on its homepage:

In this section, we see four side-by-side blocks describing who the company serves. The “learn more” button would probably be a natural fit for these, even though it’s not an ideal label.

Instead, what the designer has done is this:

• Replace the button shape or text link with a small right-facing arrow.
• Make the entire block clickable instead of a small component below the text.
• Animate the block so it turns from black to blue.
• Elongate the arrow.

This is a great way to signal to visitors that a component is clickable without having to resort to repeating the same vague label over and over again. So long as you mark the heading as an H2 or H3, it should also be clear to people using screen readers where the link will take them to next.

By the way, that’s one of the reasons why we try to avoid vague labels: accessibility. The user experience is another. Also, these labels are useful for SEO purposes. By using a descriptive label for buttons and links, search engines can better determine what the purpose and value of a linked page is.

4. Be Purposeful About Adding Links to a Page

Information overload is a real problem on the web these days. It’s not just because of how much content we throw at someone on a page. It also happens when we give them too many rabbit holes (i.e., buttons and links) to go down at the same time.

Let me show you what I mean.

This is the Start Here page on the Get Rich Slowly website:

There are 29 links on this page (not including the 10 in the header and five in the footer). This is way too much for a page of this size. It’s also too much for a page that’s supposed to be an introduction to the website.

While it’s great that there are so many resources on this site and that it all seems to connect together, shoving this many links at visitors all at once can be hugely problematic. In addition to making the content look cluttered, it could distract first-time visitors from reading through the page in its entirety before getting lost down a rabbit hole.

It’s our job as designers and writers to use discernment when creating pages. We need to decide which content is absolutely necessary and when it makes sense to divert visitor attention to another page. The homepage is one thing. But a critical part of the user journey like this one is another.

Let’s look at another example of a web page with plentiful links. This is the Personal Checking page for Cadence Bank:

There are a total of 32 links on this page. 12 of them point visitors to “Open account.” Here’s why I think this example works:

There’s a cohesive message that these buttons are telling us. Yes, there are buttons that provide supporting information about personal banking services. And there are some extraneous links at the very bottom of the page which should probably be done away with.

However, the top portion of this page is devoted to one goal: Getting visitors to open an account. So while there are lots of buttons to choose from, there’s a good chance visitors will end up in the same place as they choose their next step.

Bottom line: There’s nothing wrong with including a link in each section or block—so long as it keeps the focus on the primary goal and doesn’t overwhelm the visitor’s decision-making faculties.

5. Minimize Links Along the User Journey

Websites contain loads of information for visitors at every stage of their journey. But behind the scenes, we know there’s an ideal pathway that we want them to journey down. If we design it right, they’ll naturally take those steps to conversion.

That said, the amount of options and distractions we put in their way along that path may slow things down. And that’s not what we want.

So, the first thing to do is determine what the key pages are for your conversion pathway. For some brands, it might be as simple as TransUnion’s

This is the hero section on the TransUnion website:

There are only two buttons on the entirety of this page and they both say: “Your Free Scores & Reports.” So does the big yellow button in the header.

There’s lots of info available on the website about the service as well as educational resources related to managing one’s credit. However, the homepage doesn’t bother with any of that. Visitors are actively encouraged to take the next step in the process and to see their free credit score.

This is a great example of how you minimize distractions and click options to help most of your visitors take the right journey early on.

Not every brand can do this though. TransUnion has a very narrow solution, which is why it works. For something like Trumid, however, it would be pretty difficult to build pages with singular calls-to-action.

That said, what you can do is make the first button and call-to-action on each page take users along the path to conversion. Here’s how that looks on the Trumid website:

We know that users lose interest the more they scroll down a page. So, if you feel like it would be beneficial to include other buttons and links on the page, just make sure to do so after the primary call to action has been presented.

This is what Trumid has done.

1. On the homepage, the first button invites users to “Explore Platform.”
2. This takes them to the Trading Platform Overview page.
3. The first button on this page appears just below the fold and says “Get Started Today.”
4. This takes them to the Get Started page and contact form.

Users who are ready to convert earlier can always use the “Get Started” button in the header. Those who aren’t ready have other avenues they can go down on these pages. But at least the designer has presented them with the ideal pathway without having to work much for it—when they’re ready to do so.

Wrapping Up

To help our visitors go where we want them to go, we need to leave a trail of breadcrumbs for them to follow.

For some visitors, that trail is in the header. For others that want more information and context, they’ll hopefully follow the trail we’ve created for them on the pages of the site.

This is why we need to pay close attention to these key interactive components. From how they’re designed to their placement and usage on pages, all of these factors matter if you want to improve click-through and conversion rates.