Context

This post focuses on enterprise-scale applications, though the principles can apply broadly to various types of applications. For now, however, let’s assume the scope is large-scale enterprise applications.

Traditional UI design patterns for such applications revolve around a few core principles and areas of functionality:

1. Navigation

Enterprise applications often feature complex navigation structures to help users access diverse sections and modules efficiently. Navigation patterns must support:

• Global Navigation: Provides quick access to primary areas, often using a top or side menu.
• Hierarchical/Drill-Down Navigation: Allows users to go deeper into nested categories, suitable for applications with multi-level data structures.
• Search and Filter Capabilities: Essential in large applications, enabling users to locate specific data or modules quickly.
• Breadcrumbs and Path Indicators: Enhance user orientation by showing the current page location within the application’s structure.

2. CRUD Operations

Create, Read, Update, and Delete (CRUD) operations form the backbone of most enterprise applications, allowing users to manage data effectively. Design considerations for CRUD operations include:

• Efficient Forms: With clear, accessible fields for data entry and validation to reduce user errors.
• Bulk Actions: For large datasets, allowing users to apply changes to multiple records simultaneously.
• Versioning and History Tracking: Particularly important in enterprise environments where data changes need to be auditable.
• Permissions and Roles: CRUD access may vary by user roles, requiring robust user management and access control mechanisms.

3. Visualizations and Reporting

Data visualizations are crucial for enterprise applications, enabling users to make data-driven decisions. Key considerations here include:

• Dashboards: Providing at-a-glance information on key metrics, with drill-down capabilities for deeper insights.
• Customizable Reports: Allowing users to generate reports tailored to specific business needs.
• Real-Time and Historical Data Views: Giving users access to both live and past data for trend analysis.
• Chart and Graph Variety: Offering multiple visualization types (e.g., bar, line, pie charts) suited to the data and insights required.

4. Scalability and Performance

Enterprise applications require high performance to handle large data volumes and user traffic. Design patterns should support:

• Lazy Loading and Pagination: To optimize data load times and improve user experience.
• Data Caching and Preloading: Minimizes wait times for frequently accessed data.
• Responsive Design: Ensuring that the application works across devices, including mobile and desktop.

5. Data Security and Compliance

Given the sensitive nature of data in enterprise applications, security is paramount:

• Data Encryption: To protect sensitive information, both at rest and in transit.
• Authentication and Authorization: Implementing secure user verification and role-based access control.
• Audit Trails: Tracking changes to provide accountability and support compliance with regulatory requirements (e.g., GDPR, HIPAA).
• Error Handling and Logging: Ensures that issues are traceable and fixable, enhancing security and reliability.

6. Internationalization and Accessibility

Many enterprise applications are deployed globally and need to be usable by a diverse user base:

• Multi-Language Support: Essential for global enterprises to serve users across regions.
• Accessibility Standards Compliance: Ensuring that the application meets WCAG or similar accessibility standards for inclusivity.

In summary, these traditional UI design principles aim to create efficient, scalable, and secure applications that meet the complex demands of large-scale enterprises. By carefully considering navigation, CRUD operations, visualizations, scalability, security, and accessibility, developers can build robust and user-centered enterprise applications.

Make it Change

Most aspects of enterprise application design aim to support effective and safe data management, but the biggest challenge lies in how users consume that data. Often, in large-scale applications, navigation spans hundreds of screens. Each screen can contain multiple tabs that organize different data contexts, with information grouped based on various criteria. Some applications even require users to interact with dozens of fields on a single screen, making navigation overwhelming.

The reason for robust navigation and grouping UI patterns is to help users locate and interact with the specific data they need. This includes global navigation, search, tabs, and sections to accommodate complex data structures. However, these organizational metaphors, while effective, are dated and often fail to fully address the usability challenges in today’s data-dense environments.

For decades, we’ve relied on navigation hierarchies and data grouping to simplify complex data structures. Emerging technologies, such as augmented reality (AR) and virtual assistants, are beginning to challenge these traditional methods, introducing new ways of interacting with data. However, for now, the focus remains on improving how we structure and streamline navigation within conventional UIs to support user efficiency and data accessibility.

Complex enterprise applications can quickly lead to usability fatigue.

Dumb it Down

When designing applications with a CRUD mindset, it’s tempting to display every field that users might need. This approach, however, often leads to cluttered interfaces and forces designers to rely on tabs, groups, and other UI elements to manage the excess.

What’s missing is context-sensitive personalization—not just Role-based UI, though that’s a step in the right direction. Instead, we should ask:

• Who is the user, and what role are they performing?
• What is the user trying to accomplish?
• What information do they need to reach that goal?
• How can the UI present the data in a way that transforms it into actionable insights?

Now, the challenge becomes apparent: how much development time is available, given that achieving this level of personalization can require significant resources?

Intelligence

Imagine an application empowered by an intelligent system—an assistant that helps you work more effectively, understands your needs, and highlights critical action points without requiring explicit prompts. With generative AI advancing rapidly, we’re entering a new era, and the traditional enterprise applications we know today may soon feel like relics.

Historically, when we talk about UI/UX designers, we’re referring to people focused on creating intuitive graphical user interfaces. This focus is evolving. It’s no longer just about designing visually appealing screens, although aesthetics remain essential. We’re shifting back to the broader concept of human-computer interaction, exploring how users communicate with systems in more dynamic ways.

This future interface might incorporate voice interactions—not only allowing users to give commands in natural language but also to receive responses that feel natural and meaningful. Voice won’t be the only method, though; the application must be inclusive. For instance, users with hearing impairments should be able to interact seamlessly, and text-based natural language processing can bridge these gaps by making intent and interactions accessible to everyone.

This isn’t some distant, futuristic vision either. Today, I can ask my phone to set an alarm at a specific time just by speaking, without ever touching the device or seeing the app interface. I simply need to be close enough for it to hear me. Communication happens through natural language, and an intelligent agent interprets the context and carries out my intent seamlessly.

Of course, there are real security concerns. Who might be infringing on my privacy or recording without consent? These are valid questions, and ethical intelligence is critical for making such technology sustainable and widely acceptable.

Still, there’s no denying the efficiency boost: I achieved my goal in the fastest way possible. I didn’t have to locate my phone (a task in itself), unlock it, open the app, find the right tab, interact with the UI, and save the result. Just thinking about it feels tedious. Instead, I simply said, “Set my alarm for 2 p.m.”—and it was done.

Enterprise Agents

Can we apply the same simplicity of setting an alarm to enterprise-scale applications? The answer is yes, though the underlying technology is still evolving. But let’s set aside the technical aspects for a moment and imagine what such a UI could look like.

First, we need to move beyond traditional CRUD-based UI, with endless browser screens, edit screens, and nested tabs. Instead of navigating through multiple screens to locate a specific data field hidden within a group or tab, imagine a conversational UI that eliminates these layers entirely. No more guesswork—just two essential components:

1. Defining Intent – Allow users to communicate their goals directly, without needing to understand the backend structure.
2. Retrieving Information (not just data) – Present meaningful insights tailored to the user’s needs, rather than raw, unprocessed data.

In this approach, interaction becomes intuitive and goal-focused, with users stating what they need rather than navigating complex UIs.

Contextually Aware

Agents need to be contextually aware—but what kind of context are we referring to? First, the agent should understand who you are and the role you play. This is crucial for both security, ensuring you don’t access information beyond your clearance, and relevance, allowing the agent to provide targeted assistance that aligns with your responsibilities and goals.

I once had a discussion with a client who insisted on loading 40,000 records on the browse screen to check the status of work orders. However, scanning through a massive grid of 40,000 work orders isn’t an effective way to get actionable insights. Instead, imagine being able to express your intent in natural language.

For instance, you could ask:
“How is work progressing, and are there any areas of concern?”

The response would be tailored based on your role. If you’re a line manager, the AI knows to focus on your specific factory. It might highlight work orders that are overdue or tasks that are taking longer than expected. Instead of overwhelming you with data, it provides a clear summary or visualizations suited to your needs, making it easier to grasp the status at a glance.

Now, consider a different scenario where data is captured during a support call. A caller reports a fault with a fuel pump, so the operator starts logging a job card. They ask for the asset and site details and prepare to dispatch a contractor. However, unbeknownst to them, the same issue was already logged 10 minutes earlier, leading to a risk of duplicate work orders. If unnoticed, the contractor could be called to the site twice, wasting both time and money.

Instead, the interaction could look like this:

“I’d like to create a work order for pump 001 on site 1.”
The AI assistant responds: “What’s the issue with pump 001?”
The operator replies: “The hose is torn.”

The assistant detects a similar work order logged recently and notifies the user, showing a summary of the existing work order. The operator can then decide whether to proceed with creating a new work order or inform the caller that the issue is already being handled by contractor A.

No need for complex navigation through multiple screens.
No hunting for information across tabs and sections.

This approach streamlines the experience, allowing users to focus on decision-making rather than data retrieval.

Multiple Agents

In complex systems like this, multiple specialized agents are required, each acting as a subject matter expert.

One agent may focus on interacting with the user, ensuring smooth and intuitive communication. Another agent handles response generation, leveraging the appropriate tools to present information effectively. Additional agents enforce business rules, acting as guardians of data integrity. Some agents serve as database managers, ensuring efficient data transactions and secure storage.

Together, these agents work in concert, collaborating seamlessly to deliver reliable and cohesive enterprise functionality.

Process API

The Process API offers a JSON-based structure to define the actions we want the system to execute. While AI can certainly generate code, I’m cautious about relying on it to write code continuously for every request. Instead, the Process API provides an execution pipeline: the intent is specified using JSON, while the execution is handled by standard code in a language of choice. This functions as a feature library that the AI can utilize.

For example, creating a work order would involve invoking an action on the work order module with a “create” operation. The attributes within the JSON specify the variables needed for the action’s execution. This approach leverages predefined code, ensuring stability and reducing the need for ad-hoc code generation.

{
    "module": "workorders",
    "action": "create",
    "args": {
        "asset": "pump 001",
        ...
    }
}

The AI agent can still serve as the orchestrator of the intent, but this role can just as effectively be handled by a human developer or subject matter expert.

In this setup, the user interface agent assists the user by collecting information and shaping the intent. This intent, represented as a JSON structure, is then sent to the Process API for execution. Once processed, the results are handed back to the user interface agent for display and interaction with the user.

Considerations

What Does the User Experience Look Like?

In enterprise applications, web apps play a crucial role in simplifying distribution. By installing the application once on the server, users get the latest version simply by refreshing their browser. While it’s possible to deploy agents on the server, running them can be resource-intensive. Offloading some of these agents to the client machine helps distribute processing more effectively. Ideally, the browser should have built-in support for “Web Agents” — similar to WASM — where these agents are downloaded with the application content and perform tasks beyond the capabilities of standard web technologies.

How Do Users Express Intent to the AI?

When interacting with the AI, it’s not just about using a natural language like English; it’s about using industry-specific terminology. The AI assistant should have a vocabulary tailored to the user’s field while keeping communication clear and understandable. This ensures that the assistant not only comprehends the context but also speaks in a way that aligns with the domain expertise of the user.

Domain-Specific Agents as Subject Matter Experts

Agents should be subject matter experts, focusing on specific domains rather than adopting a one-size-fits-all model. For instance, an asset management agent should concentrate solely on asset management, providing informed answers, enforcing business rules, and following industry best practices. It should be capable of understanding the nuances of asset-related tasks, such as work order creation, and guide the user through necessary actions.

Consider a scenario where a field engineer creates a work order for an asset that requires specialized rental equipment. The agent can remind the engineer to book the necessary tool and assist in scheduling it. If the tool is unavailable on the required date, the agent should raise a flag, notifying all relevant stakeholders of the scheduling conflict. This kind of proactive assistance ensures that potential issues are communicated promptly through appropriate notification channels.

Contextual Data Presentation

Agents responsible for data presentation must go beyond simple data generation; they need a deep contextual understanding of how information is best visualized for different industries. For example, the visual needs of a mining operation differ significantly from those of a medical application. Both may require data on vibration metrics, but the way this information is presented must be tailored to the industry’s specific use case and user expectations. The agent should select the most effective visualizations based on the context, helping users consume data efficiently and make informed decisions.

The Role of Ontology in User Interface Design

When we talk about user interface evolution, we often focus on visual changes and user experience enhancements. However, a less visible but equally important layer involves the underlying data structure and relationships, where ontology can play a transformative role.

Ontology, in the realm of software, refers to a structured framework that defines the entities, attributes, and relationships within a system. It’s about building a shared understanding of the domain that the UI represents. By applying ontology principles:

1. Semantic Context: Ontology helps provide deeper context and meaning to the data displayed in the UI. Instead of showing isolated data points, a UI backed by ontology can present interconnected insights, making the information richer and more relevant.
2. Adaptive Interfaces: With a well-defined ontology, UIs can dynamically adapt to user needs by understanding the relationships between different elements. For instance, a dashboard might change its layout or provide contextual tools based on the inferred relationships from the user’s actions and the data ontology.
3. Improved Information Retrieval: Leveraging an ontology-based approach can enhance search and retrieval capabilities. Instead of relying solely on keyword matches, the UI can understand the semantic meaning of queries, providing more accurate and context-aware results.

In essence, ontology supports a shift from data-driven interfaces to meaning-driven interfaces, allowing the UI to evolve from merely displaying information to actively assisting the user in making sense of it.

Summary

In summary, traditional UI design patterns in enterprise applications often lead to complex navigation and data overload, hindering user efficiency. By integrating AI-driven natural language processing and intelligent agents, we can streamline user interactions, reduce unnecessary navigation, and present data in a more intuitive, context-aware manner. This approach not only enhances user experience but also improves operational efficiency and decision-making.