Task-Driven User Interfaces

December 8, 2014

Organizations that have IT (Information Technology) departments should be more effective than organization that lack them. If your organization doesn’t use and maintain its software and servers efficiently and effectively, that’s money down the drain.

But, while it’s easy to see the direct impact that the user experience of a consumer application has on user conversions, that’s not true of user experiences for the enterprise segment of the software marketplace. Computer software that automates the business of non-software organizations is usually slow evolving. However, the user experiences of enterprise applications do have direct impact on an organization’s performance. When the applications that an enterprise employs provide better user experiences and usability, its people are more efficient and productive. The greater the cost of human resources within organization, the bigger that impact is.

Champion Advertisement
Continue Reading…

What do an organization’s people do? Usually, they perform the duties of their individual jobs and work on tasks that their managers delegate to them. The bigger the organization, the more specialized the roles. Specialization helps people to achieve optimal performance by applying their strongest skills to a relevant task, within a specific domain—as opposed to doing everything with average success. But specialization in particular activities brings communication issues, as Figure 1 shows. In contrast, generalist workers—who may do anything, but less frequently—need to delegate and communicate subtasks to others.

Figure 1—A typical task workflow and its communications
A typical task workflow and its communications

Task-Driven Versus CRUD User Interfaces

With the need to delegate tasks and provide feedback, a number of communication tools have emerged—including voice, phones, and email and instant-messaging applications. As organizations grow, the need for the automation of task management increases. Automated task management helps managers to track and understand what is happening; reduces risks; and ensures that the right tasks get completed, at the right time.

Though automation is highly useful, many end-to-end business processes still require human interactions. For example, people may need to handle approvals or exception management or perform other activities that are necessary to advance a business process.

The concept of task flows drives task-driven user interfaces—in contrast to the Create, Read, Update, Delete (CRUD) user interfaces of many legacy applications, which is an ineffective approach to automating user actions. Unfortunately, many CRUD applications are still in common use in business and everyday life. Users of CRUD applications encounter instructions that document workflows in the following way: Open the screen that represents the data. Change the attributes of a data object. Go to a different screen and edit a value—for instance, changing xyz to abc.

To change a prescription for a patient in a healthcare application, for example, a doctor might need to do the following:

  • in a CRUD system—The doctor would find the patient profile, then the prescription; then, press Edit, change the details, and click Save.
  • in a task-driven system—The doctor would find the patient profile, then the prescription; then, press Change Prescription, edit the details, and click Save.

A CRUD workflow is fairly efficient for some types of systems—generally those that are of low value to a business. But for tasks of greater complexity and importance, CRUD workflows becomes inefficient. Plus, in such cases, the risk of error increases; a user may miss a step in a process or, if there are multiple users, they may do things in a number of different ways—making reporting in terms of user actions impossible. While it is easy to generate a report on how often object A changed, for example, it’s difficult or even impossible to answer questions such as “What steps do users typically struggle with?” or “What is typical user performance in terms of workflows completed?” and other similar analytics questions that provide actionable information.

Worklist Applications

The idea behind a task-based, or inductive, user interface is that it’s important to figure out two things:

  • How users want to use the software?
  • How the software can guide users through processes?

The task-driven user interface is the cornerstone of Command Query Responsibility Segregation (CQRS), the ultimate pattern for creating high-performance, scalable business software. As more and more organizations have become process driven and used workflow engines and Business Process Management (BPM) software to automate their processes, worklist applications, like that shown in Figure 2, have emerged. A typical worklist application lets users view a list of tasks, navigate to task details, then complete the task.

Figure 2—A typical worklist application
A typical worklist application

There are still some gaps between what the market offers and what users really need. For example, some vendors’ software lacks internationalization; in other software, basic task-management features such as task filtering and prioritization need improvement. If a task is not fully supported, its process flow must be redesigned to support alternative scenarios.

Now, let’s forget about Business Process Management, BPM software, and other technology-related jargon and, instead, focus on how people work. We must consider

  • typical tasks that a task pool comprises—what workers needs to get done
  • tasks assigned to workers—typically, tasks are assigned to workers according to priorities

It may be necessary to assign tasks directly to a particular person or to a group, creating a task pool from which workers can select tasks. For example, a company with a team that performs loan-history verifications for clients might assign tasks to people directly or to a group’s task pool—in either case, based on the geographic regions that they cover.

The three key things that any worker needs to perform a task are as follows:

  1. Context—What data does a worker need to gather before completing a task? What additional information would be useful in decision making?
  2. Instructions—How should the worker perform the task? What set of detailed instructions would a worker need to conduct a particular activity correctly.
  3. Data—What data should be the output of a task and get passed along at the completion of the task? How should a worker report the results of a task?

    Figure 3 shows a typical task flow.
Figure 3—Diagram of a task flow
Diagram of a task flow

A task definition that adequately represents a task provides answers to the following questions:

  • Who can do the task?—Include staff roles and verbs indicating the task.
  • What needs to get done?—Indicate the name of the task.
  • How will the task get done?—List the data inputs and outputs.
  • Who are the stakeholders?—List the stakeholders.
  • When must the worker complete the task?—Indicate the date on which it is necessary to finish the task.

For operations, a task becomes a work item that someone needs to get done, at some time, at some location. There are some typical patterns that occur during operations:

  • escalation—An action that must be executed if a worker were not able to perform a task for any reason, could not complete it on time, or its outputs did not satisfy exit criteria. Escalation usually leads to a supervisor’s reassigning the task, initiating another task, or canceling the task.
  • cancellation—If a task gets canceled, it may become necessary to revert all changes or take additional corrective actions. For example, if a meeting gets canceled, the calendar system may need to notify all participants about the cancellation, plus cancel the reservation of any room or other resources that are no longer needed.
  • sequential flow—The outputs from one task are the inputs for another task. As soon as one task gets completed, the next task starts.
  • parallel flow synchronization—Several tasks must be completed before the next action takes place.
  • task pool—A task is not assigned to a specific person, but to a group’s shared backlog. Each person who works from a specific task pool can choose a task from that shared pool and mark it as assigned, indicating that they are taking responsibility for the task.
  • task assignment—The method for assigning tasks to workers may be
    • static—A specific person performs a task.
    • dynamic—The worker to whom to assign a task is not known in advance.
    • rule-based—For example, depending on the total amount of an invoice, there may be different approvers.
  • reminders—A task reminder may be sent out several times—for example, based on how much time has passed since the task was assigned or how much time remains before the task expires.


Modern applications typically have task-based user interfaces. A properly designed, task-driven user interface guides a user through a process, resulting in a much better user experience. Plus, it offers context-sensitive guidance or interactive user assistance that helps a user to take the right actions. Thus, the application’s user experience becomes an integral part of the process. By focusing on user intentions and actions instead of data objects, we can take a giant step toward creating software user experiences that make users more efficient, more effective, and more productive. 

Principal Technologist at SoftServe, Inc.

Austin, Texas, USA

Oleksandr SukholeysterWith more than 10 years of experience providing technological leadership for research and development, Oleksandr focuses on accelerating Product Development Services (PDS) for advanced analytics and cloud and other high-performance solutions through technology innovations. In his work prior to joining SoftServe, he actively participated in the creation and spread of such company-wide competencies as architecture assessment, security, user interface and UX design, mobility, PaaS/Salesforce, Haskell, ALM, SOA/ESB, BPM/BPMN. He has also pioneered technological and enterprise consulting offerings. Oleksandr is certified in multiple areas of information technology (IT).His certifications include Microsoft Certified Professional, Certified TIBCO AMX Business Works Integration, and IBM Certified SOA Solution Designer.  Read More

Other Articles on Interaction Design

New on UXmatters