Understanding Complex Applications and Designing them Effectively

Modern-day brands have realized the need to leverage mobile channels to innovate and attract more users. However, that is not enough. Businesses need to design and develop complex mobile apps with simple yet effective UI that delivers a seamless user experience. In addition, UX designers need to consider the critical UX components of complex applications that consume more resources than typical applications.

Overview of complex applications 

A complex application is any application supporting broad, unstructured goals or nonlinear workflows. It allows users to accomplish overall and structured objectives and is designed for specialized domains. A specialized domain is a field that needs immense and technological expertise. In simple words, working in such a domain requires recursive and precise decision-making. On the contrary, general apps help users to execute linear tasks structured on well-defined objectives. 

How do complex apps differ from general apps?

Complex apps often deal with accomplishing nonlinear objectives without a pre-defined workflow for task completion by trained experts. For instance, an engineer has to analyze the reason behind high spikes in bandwidth usage. On the contrary, general applications usually rely on linear and discrete tasks for pre-defined objectives. 

Features of complex apps

You can make the UX design of a complex app more engaging with these features.

  • Complex apps support the needs of well-trained users who have expertise in specific domains.
  • They help in solving specific and more complex problems that vary based on the defined workflows. 
  • Complex apps allow users to manage and navigate large data sets using Analytics to aid better decision-making.
  • Complex apps apply system intelligence to mitigate risks when high-impact or high-value tasks are performed. 
  • Complex apps integrate easily with existing systems and communicate seamlessly with existing enterprise tools and platforms. 

Types of complex application users 

Designers cannot change application workflows to be less complex. What complex app users need to do is difficult for designers to understand, especially all the users' nuances. But, what designers can do is make the applications look less complicated for the different user groups. Different complex application users have their distinctions designers need to target them differently based on each scenario. These users include:

  • Learners 
  • Legacy users 
  • Power users 

When the context is about learners trying to access the complex app, the designers should simplify learnability and streamline the UX. The app should be easy to use for learners. For legends, otherwise known as power users, the app must be designed as efficiently as possible to make working easy and productive. This typically involves task automation and workspace customization. For legacy users, designers should integrate the app with good design elements and communicate its value. Legacy users often navigate bad experiences or are taught how to do something incorrectly rather than efficiently. Designers need to communicate the value of their design decisions to legacy users and ensure they have a good experience.

Importance of learnability for complex apps

UX designers can reduce the learning time of complex apps for users by promoting learnability and through user training using these methods. 

Spatial predictability: This method helps create more learnable interfaces and orient users within the app. If the location of common functionality changes between different pages, it can cause issues. Designers have to allow users to explore the application safely. There's a paradox where people are motivated to start using apps rather than learning about them or setting up parameters.

Discoverability: Discoverability fuels self-exploration. Designers need to uncover complex functionalities to users progressively. After learning the initial toolset, users will understand doing things and can improvise to do it faster.

Visual salience: Visual salience is integral to discoverability. For instance, creating guided navigation relevant to work during complicated workflows is an ideal example of visual salience for discoverability. One thing to be factored in by designers is that the users must quickly move back and forth between navigation steps.

Notetaking and navigation: A makeshift external memory often plagues users who need information (excel sheets, workflow steps, or sticky notes) to execute the actions in a complex app. Allowing for notetaking within the application eases the workflow because it doesn't require the user to reorient themselves into the application. For deep applications with many functionalities, users need to know where they are and quickly return to the home screen. Having a side menu with the application hierarchy is one example of doing this.

Naming icons: One of the essential things is to name icons that are not universally known in the application. Of course, designers can always include a setting to disable them once the user has learned what the app has to offer and its features. But until then, the extra screen real estate isn't that important.

Accelerators: These include UI features that speed up user interactions on a complex app. For example, hotkeys help reduce unnecessary moves between different menus and dropdowns based on complex workflows. Additionally, accelerators can be placed in the central/sub-menu with the critical combo next to the function or hovering over icons. Finally, tooltip help reveals accelerators in the context of the action or through in-line support, which offers more information on the functionality and using it efficiently.

Flexible contextual inquiry: Designers should provide enough flexibility for users to operate on the app based on their goals and convenience. When in-person contextual inquiries are complex, using a webcam or phone positioned over the user's shoulder or side helps designers view and note user interactions and frustrations in real-time. 

Understanding what works and what doesn't 

Designers need to advocate for more user research from the start of the design cycle since designing something that doesn't work in the real world is useless. Waiting to get a prototype ready for users will delay the design process while attracting unwanted rework or a complete overhaul. It is thus essential to creating training videos and virtual sessions with clients to thoroughly test your design, its functionalities and identify any gaps in the user's environment.

Closing thoughts

For companies looking to rehash their applications or create new ones, involving your users early before any screens are made is crucial. Also, getting them to help during your usability testing is valuable since they are domain experts and can spot things that designers may overlook. 

At Radiant Digital, we understand and design complex applications for different types of business users. So connect with us for the best recommendations today!

 


Powering Up your UX Research with Virtual Reality

Research is vital in UX development and usually involves questionnaires, surveys, and interviews. However, gauging the design's functionalities requires quantifying user interactions and participant behavior. Near-exact experiences of the actual UX design can be helpful in this regard. However, this involves complex concepts and expensive prototypes that are hardly modifiable. Virtual Reality implementation is a context-specific way to overcome these UX research challenges. It helps transport people to many places virtually, teach new skills, and even fight phobias.

We at Radiant Digital are excited about new technologies that can potentially transform how we work! Virtual Reality is one of them. In this blog, we deep-dive into where VR UX research is already in practice and how it powers up UX research.

Why VR in UX Research?

UX research involves gauging user-product interactions within a physical, social, and cultural context. Virtual Reality (VR) can enhance UX research by creating realistic-looking virtual environments (VEs) with better environmental control and ecological validity. Some of its applications include:

  • Researching workflows or interactions in developing virtual layouts.
  • Display or configuration-related details can be built, experienced, and judged in VR.
  • Safety and convenience in UX are other factors that can be effectively reproduced and evaluated by VR.

With VR, researchers can test a product’s user experience with higher visibility cost-effectively.

The Countless Possibilities

VR simulations apply to almost any actual space type in a variety of domains.

  • Workplace occupational safety: VR modeling helps tackle workplace hazards when included in training exercises.
  • Easing mental and physical health problems: VR applications are helpful in patient care, especially in diagnosis and curing phobias.
  • Educational and training environments: Educators can promote skills development by leveraging a virtual domain where the real-world consequences of failing can be avoided.

With multi-sensory features, VR helps replicate an environment for a design and its user interactions while improving the scope for understanding the product’s real-world acceptance.

VR User Testing in the Service Industry 

Providers, primarily in the IT service domain, need to test product performance in near-real environments rigorously. For example, UX researchers can use VR to inject variable attributes into their UX design in a lab setting. This helps evaluate different results for different scenarios, environments, & conditions, or geographic disparities.

VR as a UX Evaluation Tool

VR is helpful for UX research and human–product interaction. It helps with the following:

  • Obtaining insights on the users' needs and expectations by observing and evaluating the users' behavior during design interaction in a controlled environment.
  • Focusing on UX evaluation through optimizing human–product interactions.
  • Gaining information on target users and their behavior in a 3D multi-user virtual environment.
  • Gauging emotional levels during user interactions and translating that to data on the users' preferences and needs.
  • Enabling usage changes while observing natural and subjective responses.
  • Obtaining data related to performance, errors, and learnability.
  • Mediating interactions with realistic and directly controlled user avatars with motion trackers.

Best Practices for VR User Research

VR in UX combines conventional usability testing and a contextual interview. Some unique factors to consider include:

Preparation

The Environment:

  • Evaluate the space where you will conduct the VR experiments for your design.
  • Configure a "mixed reality lab" for the infrastructure to conduct augmented and virtual reality UX research.
  • Perform safety checks and remove any obstacles to free movement.

The Technology: It is essential to know the underlying technologies impacting your research in a cross-functional environment.

The Subject: Ensure your target users know what they are signing up for by briefing them thoroughly on the requirements and how to handle the experience. UX researchers should ensure:

  • Participant comfort.
  • The clarity in technology concepts and goals.
  • Digital data analysis is done before, during, and after an experience.
  • Awareness of possible motion sickness or mobility issues affecting participants.

The Equipment:

  • Test the VR equipment and the software for performance after synchronization.
  • Check if the gadgets are cleaned regularly and make users comfortable without disorienting them.

Privacy:  UX researchers should clarify what data they'd collect and how it will be used when conducting VR research from a participant's home or device.

Recruitment: Understanding the users' digital knowledge and experience in the VR space is crucial while recruiting them.

Research plan: VR combines physical, emotional, and digital experiences, which mandates clarifying the following:

  • Which aspects of UX design are you testing and whether it correlates to the device setup or the application?
  • What user behavior traits are you observing?
  • What you'll be recording and how?

Make your research seamless by setting up your research plan and the required tools.

VR User Testing

During VR sessions, you must consider the following differences between VR and conventional user testing.

Unfamiliarity with the technology: Users need buffer time to attune themselves to the technology, equipment, and environment. It is paramount to plan and explain the sequence in which the participant would navigate different experiences.

Cybersickness: Please note any symptoms and metrics (such as frame rate, session length, sudden acceleration, standing versus seated position, the participant's age, etc.) of cybersickness and only proceed when the participant is ready.

Facilitation: Noting verbal and non-verbal cues without distractions is crucial while observing the user and their interactions. VR facilitation is challenging because the user experiences a simulated environment context different from that of the interviewer.

Recording and notetaking: Ensure that participants look in your direction to record their expressions and emotional responses correctly. Use cameras and notetaking tools to obtain clear user feedback.

After the Experience 

Post-interview: UX researchers must keep a checklist to clarify the user’s experience with a design and note any negative feedback that can help fix loopholes.

Key Takeaways

VR helps identify the core concepts, evaluation methods, and limitations of your UX design to validate user acceptance. Though VR is still work-in-progress w.r.t market penetration, integrating it with UX research can unfold novel ways of fulfilling user-centric designs.

Radiant Digital can help you convert your Virtual Reality Vision to Enterprise Reality Designs. Contact us to know more.


The Significance of User Journey Mapping in Enterprise UX

The success of UX designers depends not just on the design quality and appeal but the whole user experience that their design delivers. However, they often overlook their design’s impact and focus instead on individual features and processes. Journey mapping helps deep dive into the user's thoughts, experiences, expectations, opportunities, decisions, negotiations, outcomes, etc., using a timeline of events based on a shared vision. At Radiant Digital, we implement multiple journey mapping exercises to converge visuals, narratives, and KPIs and make UX valuable. This blog explores how journey maps can give holistic insights into the user and design experience.

Defining a User Journey Map

A user journey map is a visualization of a user’s interactions and relationships with a product/brand across different channels over a defined period. It covers user actions, interaction channels, and tasks based on a user’s persona, roles, responsibilities, and goals. Here’s a sample template.

A simple User Journey map is given below.

Types of User Journey Maps

Different user journey maps help reach various goals and depend on how the user interacts with a product. Here’s a brief rundown of the user journey maps available today.

  • Experience maps offer a skeletal view of the user journey and help track scenario-based user behaviors, wants, and needs at different process phases. They help visualize the user actions to achieve the desired goal without focusing on a specific company, service, or product.
  • Empathy maps are divided into four sections where you can track what a user thinks, says, does, and feels based on what they want when using a product (without following a sequence). They are usually created during real-time user interviews about the user’s experience.
  • Current State maps illustrate the factors and levels of user engagement at every product touchpoint in its current state.
  • Future state maps replace vision boards and help envision how your customers would use your product (based on your predictions and expectations and define future events based on the best-case scenarios for a design.

  • Service blueprints reveal hiccups in the business processes of a user journey map. Customer behavior is the primary consideration in performing the customer-centric mapping. They focus on four areas, namely:
  1. User actions: What end-users do when engaging with a design.
  2. Frontstage actions: Actions on the front-end UI are visible to the customer.
  3. Backstage actions: Events and actions that occur on the backend, hidden from the user’s view.
  4. Processes: All of the enterprise events and inner processes that affect the UX design.

How to create a user journey map for your onboarding UX?

A user journey map includes the process steps from the moment a potential user learns about your UX design, all the way to where they start and stop using it. The generic sequence is given below.

  1. Defining Scope and Focus of the Map: The first step is to define the user journey map’s scope and business scenario. Representing the entire process in a single map is complex yet beneficial. The focus of the map should at least include the following:
  • The current business actions, activities, workflows, and tasks.
  • The roles involved in the UX design process.
  • Customer touchpoints and interactions (tools, devices, information involved).
  • Pain points (inefficiencies, redundancies, challenges, and gaps).
  1. Additional Map Elements: A journey map needs to tell the whole story of a user’s experience along with additional elements like:
  • Context (environment, situation, dependencies).
  • Processes performed outside the system.
  • Process contingencies.
  • Current performance metrics and KPIs.
  • Relevant legal regulations and protocols.

Deep research helps clarify what additional information you may need to depict on the map based on the story you need to demonstrate.

  1. Create User Personas: User personas are generalized profiles outlining the common user archetypes to understand who you're designing for based on their actions and goals. Once you have your user personas charted out, gather and analyze all available information on them in one of the following ways:
  • First, interviewing your actual or potential users.
  • Conducting contextual inquiry.
  • Analyzing user surveys responses.
  1. Take user intention into account: It’s essential to understand your users’ motivations and challenges while interacting with your design. Thus, for each user journey, it’s crucial to identify them,
  • Motivation: Why do users use your design, and what are their expectations?
  • Channels: Where do interactions take place?
  • Actions: What actual steps do users take and under what circumstances?
  • Pain points: What are the challenges users tend to face at different touchpoints?
  • Mental models: What is your user’s conception of the problem that your design addresses? What connections come naturally to them, and what training do they need? What emotions do they feel when using your design?

Empathy maps are helpful in mirroring the mental state of users for your designs. For example, using an emotional experience graph like the one shown below is very helpful.

  1. Map out their journey: Before constructing a map for each persona, start with a generic user journey template. Then, through user research and relevant data collection, you can complete this template with:
  • User touchpoints.
  • Benchmark tasks, actions, and results within the design.
  • Scheduled notifications.
  • Interaction channels.
  • Customer feedback and behavioral analytics.
  1. Review, validate, and refine user journey: Review your user journey map for any missing connections, challenges, and areas of improvement. Finally, present it to your stakeholders for review and feedback.

Concluding Thoughts

Creating a user journey map aims to develop a shared vision among designers, stakeholders, and end-to-end can fuel business engagement and growth. Connect with Radiant Digital to leverage user journey maps and transform your product-led user experiences.


Enterprise-First Automation and Application Modernization using Kogito

Intelligent cloud-native applications are helping enterprises spearhead innovation through automation and legacy modernization. Every application needs to deliver a specific business logic. But, workflows and rule engines make it difficult for developers. Developers need to increase their productivity and business logic efficiency in cloud environments. Therefore, the use of precise language for business workflow implementation and business rules is the need of the hour.

Quarkus projects already demonstrate the power and efficiency of working in a fast-paced development environment through native execution. However, today, business automation projects similar to jBPM and Drools need support for cloud-nativity, speed, and low resource consumption. This is why developer communities provide a way to build next-gen business applications that support native compilation in the cloud. Meet Kogito, a cloud-native business automation technology to build cloud-ready business applications while enjoying the supersonic Quarkus experience.

In Kogito, "K" refers to Kubernetes, which is the base for OpenShift as the target cloud platform, and to the Knowledge Is Everything (KIE) open-source business automation project from which Kogito originates. Being a powerful engine, Kogito allows the implementation of the core business logic in a business-driven manner. It merges tried and tested runtime components like jBPM, Drools, and OptaPlanner.

Behind the scenes in Kogito, the development of cloud-native apps are backed by:

  • Code generation based on business assets.
  • An executable model for process/rules/constraints/decision definitions.
  • A type-safe model that encapsulates variables.
  • REST APIs for business processes/rules/decisions.

These help in orchestrating distributed Microservices and container-native applications influenced by Kubernetes and OpenShift.

Made for Hybrid Cloud Environments

Kogito adapts to your domain and tools since it is optimized for a hybrid cloud environment. The core objective of Kogito is to help converge a set of business processes and decisions into your own domain-specific cloud-native set of services.

What happens when you use Kogito?

When you use Kogito, you build a cloud-native application that equates to a set of independent domain-specific services to achieve specific business value. The processes and decisions you use to define the target behavior are executed as you create services. This results in highly distributed and scalable services with no centralized orchestration. Instead, the runtime that your service uses is optimized based on what your service needs.

Kogito Implementation on Knative’s Event-driven Architecture

Kogito ergo Cloud: Kogito is designed from the basics to run at scale on cloud infrastructure. Leveraging the latest technologies (Quarkus, knative, etc.), speedy boot times, startup times, low footprint, and instant scaling on orchestration platforms like Kubernetes is possible.

Kogito ergo Domain: Kogito strongly focuses on building domain-specific services using APIs and JSON data. This prevents any leaking of tool abstraction into your client applications. To achieve this, Kogito relies on code generation, which takes care of 80% of the work in a domain-specific service (or services) based on the defined processes and rule(s). Additionally, you can expose domain-specific data using events or a data index for other services to consume and query it easily.

Kogito ergo Developer: Kogito's battle-tested components offer a power-packed developer experience to achieve instant efficiency by having:

  • Tooling to build processes and rules for cloud-native services is embedded wherever required. For example, the Kogito BundleVSCode extension enables you to edit your Business Process Model and Notation (BPMN) 2.0 business processes and Decision Model and Notation (DMN) decision models directly in your VSCode IDE, next to your other application code.

The Kogito Operator Framework lets you deploy services in the cloud. It is based on the Operator SDK and provides deployment steps automation. For example, a link to the Git repository containing your application helps automatically configure the components required to build your project from the source and deploy the resulting services.

Kogito's command-line interface (CLI) simplifies these deployment tasks.

  • Code generation that automates 80% of the processes.
  • Customization flexibility.
  • Simple local development with live reload.
  • Instant productivity where a service can be developed, built, deployed, and tested to avoid delays. On Quarkus and Spring Boot, a dev mode helps achieve this. Quarkus even offers a live reload of your processes and rules in the running application, which offers advanced debug capabilities.
  • Components based on well-known business automation KIE projects, specifically jBPM, Drools, and OptaPlanner, offer reliable opensource solutions for business processes, rules, and constraint solving.

Why Kogito?

Cloud-first priority: By leveraging Quarkus and container orchestration platforms like Kubernetes/OpenShift, Kogito lets cloud-native apps run at scale along with superfast boot times.

Domain-specific flexibility: Kogito can be customized to specific business domains to avoid leaking workflow tool-specific application abstractions while interacting with the workflows.

Developer-centric Experience:

  • Kogito enhances the developer experience (based on VSCode) to achieve instant efficiency with embeddable tooling wherever required.
  • Kogito tooling (Codegen) automatically generates code for a minimum of 80% of workflows with the flexibility to customize and simplify application development.
  • Advanced Local test/debug, hot reload.
  • Integrated into existing developer workflow.
  • Reusable building blocks.
  • Rapid prototyping.

Optimized for Cloud and Containers

  • Small footprint
  • Fast startup
  • Dedicated Generated runtime + optional add-ons
  • Serverless architecture

Technology Enabler

  • Cloud events
  • Event-driven
  • Serverless with knative
  • Machine-learning support
  • Grafana/Prometheus

Other benefits include:

  • Runtime persistence for workflows for preserving the process state for instances across restarts.
  • Supports events and enables integration with third-party systems using external REST API calls.
  • Enables process instance progress tracking from the Kogito process management console.
  • Provides security to application endpoints by integrating with an OpenId Connect (OIDC) Server.

Latest Kogito Features

The Kogito 0.8.0 release has 25+ new feature requests, 35 enhancements, and more than 40 Kogito Runtime bug fixes. The VS Code editor has been updated with bug fixes and improvements to Chrome extensions for Business Process Model & Notation (BPMN) and Decision Model & Notation (DMN). In addition, new online editors make them more robust.

Here are the top features.

Online authoring Tools: Kogito offers authoring tools to increase the productivity of business automation experts who author executable business logic in the cloud. The latest release gives Kogito online editors for BPMN and DMN ready-to-use and does not require any local setup. You can use these editors to sketch BPMN-based business-process diagrams or business decisions based on DMN specifications.

Kogito Management Console: The new Kogito Management Console helps view and manage process instances. The Kogito Data Index in the new management console aids visualization and management for process-instances and domain-based views. Developers will get a detailed picture of running process instances, variables, sub-processes, and task execution workflows.

Kogito Domain Explorer: This feature helps navigate business data in a selected domain.

Multiple Run-time Modes: For Quarkus and Spring Boot, Kogito supports the following modes.

  • Development mode: For local testing. This mode offers live processes and decisions reload in your running applications for advanced debugging.
  • JVM mode: For Java virtual machine (JVM) compatibility.
  • Native mode: Quarkus requires GraalVM. This mode is used for direct binary execution as native code.

Meaningful process IDs

The meaningful process IDs simplify the correlation of new processes with the existing business information. In addition, these give the option to create a unique reference for a business key even if you use auto-generated process IDs.

You can create a unique reference by passing a query parameter named businessKey in the request to start a new process instance. For example, you can start an order process correlated to the business key by sending a request similar to the below example:

POST /orders?businessKey=ORDER-0001

You can then retrieve the new process instance with the new reference ID similar to the one given below.

GET /orders/ORD-0001

The following HTTP request deletes the process instance with the same reference ID:

DELETE /orders/ORD-0001

Process-variable tagging

The Kogito runtime supports process-variable tagging. Developers can provide the metadata about a process variable and perform model-based process grouping if required. For example, important business KPIs are grouped and classified this way using process inputs and outputs; and variable tags are internal or read-only.

Kogito Operator and Kogito CLI

Kogito Operator and Kogito CLI are based on the popular Red Hat OpenShift Container Platform where the Kogito Operator helps deploy Kogito Runtimes from the project's source with facility for developer interaction with Kogito Operator from the Kogito CLI.

You can set the -enable-istio parameter in Kogito CLI after creating a new Kogito application to enable Istio service mesh sidecars. The sidecars can then automatically combine tracing, observability, security, and monitoring in your Kogito pods.

Kogito Jobs Service

The Kogito Jobs Service offers a lightweight and dedicated solution for scheduling two types of jobs. A time-scheduled job executes only once at a given time, and a periodically scheduled job executes at the given interval and executes a predetermined number of times.

Decision and process integration

Kogito supports the modeling of a decision-driven service as either a self-contained service or based on intelligent workflows and decision tasks. For example, you can implement business decisions using Drools rules, decision tables in a spreadsheet, or DMN models where Kogito automatically generates REST endpoints for you.

In Kogito 0.8.0, this feature allows the integration of DMN models with BPMN processes to drive business processes by intelligent decision nodes.

Technologies used with Kogito

Kogito is compatible with the latest cloud-based technologies like Quarkus, Knative, and Apache Kafka, to increase start times and instant scaling on container application platforms, such as OpenShift.

  • OpenShift is based on Kubernetes and the target platform for building and managing containerized applications.
  • Quarkus is a native Kubernetes-based Java stack used to build applications with Kogito services.
  • Spring Boot support is available for Kogito, where you can use the Spring Framework.
  • GraalVMwith Quarkus provides native compilation with Kogito, resulting in fast startup times and a minimal footprint. As a result, a fast startup is available, especially for small serverless applications.
  • Knative allows building serverless applications with Kogito that can be scaled up or down (to zero) as needed.
  • Prometheus and Grafana can be used for monitoring and analytics with optional extensions.
  • Infinispan and MongoDB are middleware technologies that offer persistence support.
  • Kafka and Keycloak are middleware technologies that support messaging and security.

   Kogito on Quarkus and Spring Boot

  • Kogito supports primary Java Frameworks like Quarkus (recommended) and Spring Boot.
  • Quarkus is Kubernetes-native with a container-first approach to build Java applications, especially for Java virtual machines (JVMs) such as GraalVM and HotSpot. As a result, Quarkus reduces the size of both the Java application and container image footprint to optimize for Kubernetes while eliminating some Java programming workloads from older versions and reducing the memory requirement to run those images.
  • For Kogito services, Quarkus is highly preferred to optimize Kubernetes compatibility and enhanced developer features like live reload in the dev mode for advanced debugging.
  • Spring Boot helps build standalone production-ready Spring applications. Spring Boot-based applications require minimal configurations without an entire Spring configuration setup.
  • For Kogito services, Spring Boot is ideal for developers who need to use Kogito in existing Spring Framework environments.

Kogitos Architecture

When using Kogito, a cloud-native application is built by collaborating a set of independent domain-specific services to achieve some business value. The processes and rules describing the service behavior are executed as part of the services and are highly distributed and scalable without a centralized orchestration service. This way, the runtime of your service is fully optimized on a need basis. For long-lived processes, the runtime state must be persisted externally using a data grid, like Infinispan. Each service also produces events that can be aggregated, indexed in a data index service, and consumed to offer advanced query capabilities (using GraphQL).

Deploying a Custom Kogito Service on Kubernetes with Kogito Operator

Kogito Magic- Behind the Scenes

Kogito starts by reading business assets like a BPMN2 file, decision tables, or Drools rules and creates executable models using Java Fluent API. Here, developers can leverage Quarkus' hot-reload feature to update a business process diagram, save it, and test the changes instantly without a server restart. Kogito automatically generates an executable business resource for every business asset and REST endpoint that allows client apps to interact with processes, tasks, and rules in a more domain-driven way. This business automation tool increased productivity and faster business logic validation using easy-to-maintain business assets, the hot-reload feature, and quick application bootstrap during the development phase. While executing the Kogito business application, if the user wants to compile it to run in the native mode with GraalVM, the business rule execution can be run 100 times faster with 10x lower resource consumption when compared to a JVM execution. Once started, you can access the application after boot with no additional processing. Finally, with the Kogito operator, the user can create a new Kogito application or deploy an existing one through the UI or CLI tool.

Wrapping up

Kogito's Serverless Workflow specification can help define complex workflows, which can be helpful across multiple platforms and cloud providers. Developers can now rely on this platform fully compliant with standards and the specifications needed for cloud-native business application automation.

Connect with Radiant Digital's experts to explore the advantages of Kogito for your cloud-native enterprise applications.

 


Understanding Data Visualization from a UX Designer’s Perspective

In today’s digital world, the number of connected devices that generate data has increased exponentially. Recent research by IDC revealed that the global data volume would reach 163 trillion gigabytes by 2025. With more businesses relying on this data for decision-making, the design of business dashboards has gained prominence in the past decade. UX designers often need to coherently and visually communicate quantitative data to their teams and users. Thus, it’s paramount for them to follow the best practices in making data representations engaging. With the power of data visualization, UX designers can create effective analogies that can simplify complex datasets for human minds.

At Radiant Digital, we help clients make the most of their business data by leveraging data visualization in UX. In this blog, we focus on how data visualization is a crucial enabler for decision-makers to simplify concepts, identify new patterns, and obtain actionable insights for better decision-making.

What is data visualization?

Data visualization is a representation technique that involves restructuring datasets to obtain actionable insights. It uses graphs, charts, images, and other formats to convey complex ideas and logic better. UX designers must familiarize themselves with visualization to best represent data in their designs.

What does data visualization offer?

  • Simplicity: Data visualization simplifies data analysis by converting data into color bars, lines, circles, and other visual attributes. The human brain can comprehend different datasets by converting them into easy-to-understand and communicating trends, patterns, behaviors, and conclusions.
  • Fidelity: For a given context, a colored chart/graph can enhance the quality of your UX design, including its look and feel. On the other hand, data tables make data hard to understand by individuals who are not experts.

Benefits of data visualization

  • Data simplification: A large volume of unstructured data can seem overwhelming for users. Data visualization makes it easy to comprehend by blending pie charts, graphs, line charts, etc.
  • Expedited decision-making: Data visualization helps gain quick insights into many data patterns. Hence, leaders can make informed decisions based on them with more confidence and without manual intervention.
  • Personalization to meet business needs: When UX designers handle raw datasets, they can use custom designs to personalize and represent them. As a result, they can render different visualization perspectives and deliver value to other user groups using the same data. For example, the same data can represent information differently to marketers, finance managers, and HR teams.

Critical considerations for data visualization

  • Capturing the intended message: When focusing on representing complex datasets, you should emphasize accuracy apart from efficiency and transparency: select chart attributes, colors, and designs to communicate information correctly. The type of chart you’ll use should be dependent on the context itself. So, keep checking on your goals to ensure that the intended message is not getting lost in the visualization project.
  • Designing to populate a large volume of datasets: The data visualization placeholders created initially may not always accommodate the required datasets. This results in a critical communication gap between the actual data and the framework. In such situations, UX designers should build a scalable data framework that flexibly accommodates large datasets.
  • Understanding the tools and technologies: You should know about your handling situation and which visualization tools/components will fit the best in such cases. Implementing an incorrect feature can mislead the audience and may even fail to communicate the underlying information. Instead, your intent should be to convey full info with suitable graphs and colors.
  • Embracing inclusivity: Adding colors to data visualization doesn’t add visual attractiveness. However, a study by Salesforce has revealed that colors are significant factors behind consumer decision-making. In addition, this study has shown how the application of different color palettes can add aesthetic value to other datasets. Here’re some tips that can be useful for you in this regard: Use various labels and icons; try to use colors with high contrasts; use colors and patterns to communicate different types of information.
  • Handling distortion: Taking care of data distortion is a must during a data visualization project. Remember that you’re trying to tell a story here, and distorted data can become a barrier there. Using proper color choices, appropriate data points, befitting data charts is essential in data visualization. In addition, you don’t want the audiences to reach a wrong conclusion from distorted datasets.

Methods to visualize your data via UX design

Bar graphs

If you’re dealing with datasets that can change over the years or are based on specific categorizations, bar charts would be ideal for representation. Here are a few helpful tips.

  • Maintain a chronological order of information represented by bars.
  • Include two axes: one for the timeline and the other for quantities.
  • If you’re trying to visualize datasets with multiple categories and don’t have any time restrictions, you can place the bars in either most to most minor or least to most orders.

Line graphs

Line graphs help visualize specific datasets for a particular period. Combining them with bar charts helps visualize critical business datasets effectively. However, line charts represent deviations more efficiently and organically.

Pie and donut charts

Pie charts and donut charts are critical data visualization attributes. However, these charts are often misused, considering most people fail to understand their purpose and the type of data best suited for them.

Heatmaps

Heatmaps contain large areas, often parted into different sections, cells, colors, etc., to represent a content group. For example, in heatmaps, dark shades represent popularity or high frequency, while lighter shades indicate lesser traffic.

Retrospective

Edward R. Tufte once said, “the essential test of design is how well it assists the understanding of the content, not how stylish it is.” Data visualization through UX design can simplify information to a wide range of users.

At Radiant Digital, we apply the best practices in data visualization to make data genuinely valuable for enterprises and their customers. Connect with us to transform how you represent information.


Understanding the Designer-Developer Collaboration to make UX Designing Frictionless

In the UX design world, the contributions of designers and developers are equally essential to shaping its success. Good design is not always about the product but the process leading to it. As experts say, when developers and designers work together, magic happens. But this magic can manifest into great designs only if the existing collaborative gaps between these two groups of experts are closed sooner than later. Designers should not limit themselves to sharing specifications, assets, interactions, mockups, etc., with developers. These two professionals must share a common objective that is an exceptional user experience for design intent. Design clarity must be integral to ideation, mockup, wireframing, and prototyping. Finding an optimum solution becomes easier when designers and developers communicate well and collaborate even better. They must strive to educate each other better and learn at the same time. Cross-functional knowledge and a dynamic approach are pivotal to a great collaboration. As remote collaboration is the new way of working today, we’ve moved from colorful post-its to email reminders and whiteboard sessions to video calls.  Therefore, designers and developers must accustom themselves to better and powerful ways of collaborating and communicating. This blog gives you insights into the challenges of designer-developer collaboration and tips on how to improve it.

What is designer-developer collaboration?

Aaron Walters of InVision states, "Designers and developers probably have more in common than they realize."  Designer-Developer collaboration describes a relationship with a shared understanding and objective of producing high-quality and functional UX designs. While designers only think about design systems, developers need to focus on simplifying modular code. But the way the processes are executed may be slightly different. This is where a common ground for collaboration and communication helps. They could use various collaboration tools during different phases or take advantage of other collaboration mechanisms mentioned in this blog. Before we delve deeper, let us highlight the benefits of seamless designer-developer collaboration.

  • Designers and developers can gain familiarity with the design, processes, and other person's ways of working, which helps them contribute to tasks more effectively.
  • With a common strategy, design, and execution, both teams can decrease their learning curves and deliver faster.
  • It helps create a healthy and conducive collaborative environment where team members can take complete ownership of their work.
  • Collaboration provides new learning experiences to implemented individual tasks. This enriches their thought processes and improves project engagement.
  • Working as a close-knit team helps nurture a healthy working environment, improve problem-solving, and lead to more valuable contributions.
  • Revenue goals are met faster if there is no blame game and deliverables are rolled out more quickly without compromising quality.

The advantages mentioned above help address the following collaboration pain points. It is often difficult for designers to work with developers and vice versa because of distinct backgrounds, mindsets, and approaches, leading to ego clashes or stalled work. Both designers and developers may need to work together and complete projects such as website designs, product interfaces, mobile app revamp, and digital marketing campaigns. However, despite working together, there is always some disconnect between the two teams. Here are some role-based pain points that both teams need to address for seamless collaboration and positive results.

  • Design is about aesthetics and dimensions, while development is about functionality, usability, and scalability.
  • Designers shape the product while developers bring them to life. A lack of understanding about the intent of a design causes disparities, misunderstandings, and disagreements.
  • Design is about the finer details, and developers have an eye for detail. If elements and features are undiscussed with the developers, the result is a product disaster.
  • Unnecessary back and forth loops take place due to a lack of cross-domain understanding. This wastes a lot of bandwidth and delays the QA process.
  • Design is evolving, and the lack of constant updates can put teams behind and cause confusion instead of clarity.

Challenges in designer-developer collaboration

Despite being critical players in UX design, designers and developers often remain isolated and siloed with limited communication. This raises the following challenges.

Variation in time evaluation: UX designing cannot be done overnight. Designers need to consider layout, user interface, design aesthetics, user experience, and much more. However, designers commonly make haphazard and wrong time estimations leading to a time crunch for developers to build these designs.

Inclusion of developers towards the end: Involving the development team when the process is done leads to complex, chaotic processes and severe setbacks.

Lack of mutual consideration: From the kick-off to the delivery stage, designers' planning that includes defining timelines, tasks, design, development, and collaboration methods usually does not involve the developer's point-of-view. Similarly, developers rarely pitch in designers when they develop prototypes and get them tested. This leads to disagreements and significant rework later.

Misconceptions about UX design work: For many developers, design work is perceived as an extra burden. This comes from a lack of understanding of the science behind UX design. Making an aesthetic and helpful interface must include multiple prototypes to understand the designer's perspective as well.

Muddled communication: Good communication is the foundation of a great UX design. Effective communication eases the process and the road to the final product. Unfortunately, most designers and developers draw a line between their teams and don't practice the proper communication techniques. While developers are bound to talk technicalities and code specifics, the designers prefer talking about creative ideas and the beauty of the design. This causes misunderstandings and process slowdown.

Wrong implementation due to misunderstood design or complex handover: A design handoff occurs when the design and prototypes have been tested and are being handed off to developers to start coding. A complicated or unclear handover is a developer's worst nightmare. And writing a novel-length specifications PDF is not ideal either. Using collaborative tools during different phases of design development is highly beneficial.

Ways to Improve communication

Experts recommend the following tips to improve designer-developer communication.

Kick-off meetings: These icebreaker meetings must take place between designers, developers, and clients. This way, vague discussions and conversations are avoided to obtain clarity. For example, designers should not hold back explaining the exact design to the developers. Similarly, developers must coordinate with designers to replicate their designers in the best way. Kick-offs help exchange visions of design and development, communicate the challenges, and derive solutions.

Avoiding assumptions and talking about processes: Designers and developers have their respective product assumptions. Both teams should start communicating earlier and zero in on the core problem or requirement to avoid discrepancies. Also, developers must clear their doubts about design to come up with the best solutions. Effort estimations and plan B must be discussed openly and confirmed mutually. This saves the time spent is unraveling mysteries and course corrections later in the design process.

Frequent testing and designer feedback: Designers must prepare sketches or virtual prototypes and continuously share them with the developers for feasibility study and feedback. Similarly, developers must focus on user experience improvements, frequent user testing, and design validation from designers. They need to measure the design usability from the designers' point of view. Tools like zipBoard, Notable, and Usabilla are handy for this.

Unleash the common framework: Designers and developers often use different frameworks for a joint project based on their requirements. Since these frameworks differ significantly, it usually leaves both departments frustrated. Common frameworks like Bootstrap are now available to help developers and designers stay synchronized and rapidly build web applications or websites. Adapting to a common framework helps reduce complexities while saving time and effort.

Making each other's lives easier

What should designers do?

  • Reuse design components and views when possible.
  • Maintain color palettes, design elements, icons, etc., uniformly to reduce distractions.
  • Utilize grids and breakpoints to improve design responsiveness when it is coded.

What should developers do?

  • Understand design intent and motivations and put them into practice.
  • Gain essential knowledge about graphic design and participate actively in design discussions.
  • Engage in design brainstorming sessions to clarify what can be developed and what can't.
  • Try and evaluate the evolving design from a functional viewpoint to reduce rework and delays.

Proven ways to improve collaboration 

Common focus on the end-user: Following a common goal like user experience through usability testing helps designers and developers perform better and empathize. The Nielsen Norman Group gives us a checklist on usability testing for both designers and developers.

Collaborate from the beginning: A recent study by the Department of Industrial Engineering and Management at the University of Oulu in Finland concluded that early collaboration leads to:

  • Fewer chances of producing inferior products
  • Greater satisfaction for the end-user with regards to functionality and usability
  • Room for improved solutions and

Standardize operations and processes: A standardized order of operations and processes helps speed up work and steer clear of any miscommunication. Clarity on the common oversights like naming conventions, sizes, margins, paddings, etc., for designers and developers, helps reduce logistical issues. When it comes to systems and processes, a thorough checklist can help teams stay focused, take ownership, and complete crucial tasks before moving on to the next design development phase.

Frequent check-ins: This does not mean micro-management but ensuring that all the stakeholders are on the same page regarding the project progression. By having frequent check-ins between designers and developers, you're able to keep the project moving along by removing communication and interpretation bottlenecks.

Implementing collaboration tools 

Developers often wait on the design team to deliver sample designs and then proceed with the development. This method is simply not practical. Tools like Zeplin and InVision improve collaboration efforts with better transparency and direction. In addition, collaboration tools can be used in different phases of design development. Here are some excellent tools both designers and developers can use.

Mockplus cloud is an all-in-one collaboration and handoff tool for designers and developers to prototype, collaborate, and handoff designs in one place. The features include:

  • Design imports with assets from Sketch, Photoshop, Adobe XD, and Figma.
  • Upload prototypes from Justinmind, Axure, Mockplus, and documents.
  • Create UI flows and interactive prototypes using drag-and-drop.
  • Comment, test, review, and iterate designs with simple clicks.
  • Inspect, copy and download design specifications, assets, and code.

Zeplin is a design handoff tool that helps translate your designs into CSS, Swift, Android, Objective-C, or React Native code while also exporting layers and marked assets. The key features include:

  • Integrates with Sketch, Figma, Photoshop, Jira, Slack, and Trello.
  • Generates RGB and HEX values for your designs.
  • Provides buttons, layers, and icons with marked assets.
  • Supports iOS, Android, and web platforms.

Cage is an online media collaboration tool that allows designers and developers to share and present workflows for creative review. Cage helps you plan and complete projects with a unique mix of tools. With all of your team's tasks, discussions, files, and activities in a single location, the status of projects and team performances are transparent on this platform. The core features include:

  • Access controls and permissions.
  • Communication Management.
  • Content management.
  • Comments and feedback.
  • Third-party integrations.
  • File sharing.
  • Drag and -drop.

Invision provides insightful feedback through clickable design prototypes on native devices. It prevents the need for static PDFs or oversized sitemap-style documents. Instead, real-time comments and feedback help designers and developers resolve issues sooner. The other features include:

  • Link sharing to view designs in the browser or on a mobile device.
  • Real-time screen-sharing of projects and meeting with LiveShare.
  • Conversation organization around design component specifics using threaded comments.
  • Daily feedback emails, comment feeds Sort by date, screen, read, unread, and more, activity feeds and follow-ups.
  • Password protection for designs.
  • Easy browser, drag and drop, and automatic sync through Dropbox integration.
  • Upload PNG, JPG, PDF, or GIF files for feedback using any low and high-fidelity designs design tool.

Bitrix24 is a collaboration workspace that helps handle daily operations & tasks. It is used primarily for CRM, Project Management & Collaboration in the Cloud or on-premise. The key features include:

  • Collaboration (chats, polls, stream messages, telephony integration, voice & video calls).
  • CRM (leads, contacts, invoices, web forms, deals, sales reports automation, open channels integration, website widget).
  • Project Management (tasks, subtasks with Kanban, dependency management, recurring tasks & task time-tracking).
  • Document Management (file storage & sharing, data synchronization and integrations, and workflows for document library).
  • Time Management (task time automatic calculation & summary, reports, shared calendars).

Mural offers a dynamic and virtual environment to share and visualize design ideas. In addition, it helps run productive meetings and workshops in public and private modes. The key features include:

  • Easy integrations with Dropbox, Slack, GitHub, and other productivity tools.
  • Built-in and ready-to-use templates.
  • Enterprise dashboards for performance management, insights, and controls.
  • Security protocols, versatile safeguards, and global standards.
  • Frameworks to organize content and gain design insights.
  • Drag-and-drop images and GIFs.
  • Free-hand sketching.
  • Build visual stories using icon libraries.
  • Shapes and connectors for building diagrams and mapping complex workflows.
  • Sticky notes and text for ideas, thoughts, and feedback.

Red Pen is an effective feedback tool that helps designers with constructive criticism on a project. It lets you drag and drop designs into your dashboard and invite specific developers or clients to share their thoughts in real-time as you roll out your latest updates. In addition, red Pen helps keep track of multiple versions, so you don't lose earlier designs. The key features include:

  • Point-and-click to provide feedback.
  • Live comments.
  • Sharing a private link to a collaborator for feedback.
  • Drag states, screens, and alternatives to do a project.
  • Version tracking and instant change status updates.

Five foundational principles of designer-developer collaboration

  1. The developer is your user: Your user will interact with the final product built by developers, based on the design handoff you give.
  2. The only certainty is change: Design needs to be flexible and scalable, depending on the changing needs of your end-user.
  3. Design must evolve at every step: As a designer, your work will never be done. So expect use cases and questions from the team while development is ongoing.
  4. Less is more: When visionary German designer Dieter Rams says less is better, you listen.
  5. Find your passion and go with it: Empathy and focus are at the helm of a good product design.

Questions designers should ask developers

Before creating your artboard, ask these questions to your development team for better clarity.

What handoff tools are we using? Ensure you and the developer are on the same page for tools based on project needs and team strengths. This will ease the production process.

What asset management strategy are we using? Asset management helps track the components, files, tools, frameworks, and software used in the design process. Clarity and direction in this regard save a lot of frustration.

Do we follow a particular file-naming convention? Many handoff tools do not auto-generate design layer class names. Discussing naming protocols early will save a lot of confusion later.

Do the frameworks/libraries we use put constraints on design/technology? Having an in-depth understanding of Android components and material design will prevent unsolicited rework. Using responsive grids for Sketch artboards based saves a lot of implementation headaches.

How to depict states, micro-interactions, or animations? Interaction design and states are highly dependent. Therefore, developers need to be briefed in the early stages of production, aligning with their individualistic approach.

Outcomes of effective collaboration

  • Gaining familiarity with internal teams, expectations, and processes.
  • Overcoming fears, gaining clarity and confidence in delivering exceptional designs.
  • Learning cross-functional practices that can impact design or development workflows.
  • Establishing a good work culture and rapport to improve performances.
  • Aligning on the end vision.

Retrospective

Today, technology-based collaboration is the cornerstone of any organizational success. This is no different for designers and developers. However, these two teams often find it hard to reconcile and enable frictionless collaboration. Therefore, it is essential to bridge any communication gaps that hamper an excellent product from becoming a great product. On the brighter side, designers are spending significant time on developer collaboration tools with an engineering mindset. While engineers use tools like InVision to inspect design elements, check specifications, and break down the design system to more specific coding elements.

Are designer-developer collaboration issues impacting your enterprise performance?  Connect with the experts at Radiant Digital to adopt the most suitable collaboration techniques for your organization.