Process execution guidance based on process model

Abstract

Example embodiments relate to systems and methods that may provide a guided user interface session for user input of a software process based on annotations added to a process model of the software process. In one example, a method may include receiving runtime data of an instance of a software process from a workflow engine that is executing the instance of the software process, determining a process activity expected to occur next within the running instance of the software process, the method includes determining a flow activity of a software flow, identifying a subset of input elements within a graphical user interface (GUI) mapped to the determined flow activity and the GUI based on annotations within a flow model of the software flow, highlighting the identified subset of input elements, and disabling any remaining input elements within the GUI to generate a guided GUI, and displaying the guided GUI via a computing system of the user.

Description

Technical Field

[0001] Organizations often rely on enterprise resource planning (ERP) software and the like to run their business processes through software. The software can be used to generate documents such as sales orders, invoices, receipts, shipping orders, etc. using various software systems. The software can also help organizations create and track orders, generate and settle invoices, receive payments, interact with websites, etc. However, one of the drawbacks of ERP software is that many processes continue to rely on user input. Background Art

[0002] In many cases, users may become stuck or delayed because they are unsure of which commands, fields, inputs, etc. are required on the corresponding user interface. This problem is exacerbated when updates are made to the process that the user is expected to follow and / or the user interface changes the user interface in some way (e.g., the positioning and labeling of buttons). In response, users of the system must detect which changes affect their responsibilities and learn new processes for performing their responsibilities via the user interface, often supported by an ever-increasing amount of documentation that they must complete in order to perform the process as desired. This is a difficult task for many users. Summary of the invention

[0003] In one aspect, a computing system is provided, comprising: a storage device configured to store a process model of a software process; and a processor configured to: receive runtime data of an instance of the software process from a workflow engine that executes the instance of the software process; determine a process activity that is expected to occur next within the instance of the software process based on the runtime data; identify a subset of input elements within a graphical user interface GUI and the GUI that are mapped to the determined process activity based on annotations within the process model of the software process stored in the storage device; highlight the identified subset of input elements and disable any remaining input elements within the GUI to generate a guided GUI; and display the guided GUI via a user's computing system.

[0004] In another aspect, a method is provided, comprising: receiving runtime data of an instance of a software process from a workflow engine that is executing the instance of the software process; determining, based on the runtime data, a process activity that is expected to occur next within the running instance of the software process; identifying, based on annotations within a process model of the software process, a subset of input elements within a graphical user interface GUI and the GUI that are mapped to the determined process activities; highlighting the identified subset of input elements and disabling any remaining input elements within the GUI to generate a guided GUI; and displaying the guided GUI via a user's computing system.

[0005] In another aspect, a computer-readable medium is provided that includes instructions that, when executed by a processor, cause a computer to perform a method, the method comprising: receiving runtime data of an instance of a software process from a workflow engine that is executing the instance of the software process; determining, based on the runtime data, a process activity that is expected to occur next within the running instance of the software process; identifying, based on annotations within a process model of the software process, a subset of input elements within a graphical user interface GUI and the GUI that are mapped to the determined process activities; highlighting the identified subset of input elements and disabling any remaining input elements within the GUI to generate a guided GUI; and displaying the guided GUI via a user's computing system. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] Features and advantages of example embodiments and the manner in which the same are achieved will become more apparent with reference to the following detailed description taken in conjunction with the accompanying drawings.

[0007] Figure 1 is a schematic diagram illustrating a host platform for generating a booted flow execution according to an example embodiment.

[0008] Figure 2A is a schematic diagram illustrating a user interface for annotating a process model with user interface elements according to an example embodiment.

[0009] Figure 2B is a diagram showing a method of performing Figure 2A Schematic diagram of the mapping generated by the annotation process in .

[0010] Figure 2C is a schematic diagram illustrating a process of mapping process activities to user interface locations within a mapping table according to an example embodiment.

[0011] Figure 3 is a diagram illustrating a process for determining a next action of a process based on a current state of the process according to an example embodiment.

[0012] Figure 4A is a schematic diagram of an inbox view showing items requiring attention according to an example embodiment.

[0013] Figure 4B is a schematic diagram illustrating a user interface with a fully guided approach according to an example embodiment.

[0014] Figure 5 is a schematic diagram illustrating a method of generating and outputting a guided flow execution according to an example embodiment.

[0015] Figure 6 is a schematic diagram illustrating a computing system for use in examples herein, according to an example embodiment.

[0016] Throughout the drawings and detailed description, unless otherwise described, the same drawing reference numerals will be understood to refer to the same elements, features, and structures. The relative sizes and depictions of these elements may be exaggerated or adjusted for clarity, illustration, and / or convenience. DETAILED DESCRIPTION

[0017] In the following description, specific details are set forth in order to provide a thorough understanding of various example embodiments. It should be understood that various modifications to the embodiments will be apparent to those skilled in the art, and that the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present disclosure. In addition, in the following description, many details are set forth for the purpose of explanation. However, it should be understood by those of ordinary skill in the art that embodiments may be practiced without using these specific details. In other cases, well-known structures and processes are not shown or described to avoid obscuring the description with unnecessary details. Therefore, the present disclosure is not intended to be limited to the embodiments shown, but to conform to the widest scope consistent with the principles and features disclosed herein.

[0018] Business Process Modeling Notation (BPMN) is a flowchart technique for representing the stages of a business process from start to finish. It provides a visual representation of the complex flow of business operations and information required to complete a process, which is essential for business process management. In layman's terms, a BPMN model is a picture of what the process should look like. For example, a diagram can include nodes representing activities in a process (e.g., a sale occurs, an invoice is generated, a payment is received, a product is shipped, an invoice is cleared, a delivery is confirmed, etc.) and edges in the diagram representing the order / dependencies between the activities.

[0019] At the same time, a workflow engine such as a BPMN engine is able to interpret a process model such as a BPMN model and execute the corresponding complex business process represented in the flowchart. For example, a workflow engine can interpret the signs, symbols, nodes, edges, directional arrows, etc. within the process model and execute an instance of the process. During execution, the workflow engine can identify and track / monitor the current state of the process instance, such as the location within the process / flowchart where the process is currently located. Here, the workflow is usually initiated or resolved by the workflow engine based on a preset time and deadline, so that when a task is completed, the workflow engine initiates another manually guided task. The workflow engine can also handle internal network server tasks, and the workflow engine can automate these tasks through a set timing cycle. The workflow engine can route a series of tasks, pushing them from one step to the next step.

[0020] Although the BPMN model shows how to execute the expected flow of a software-based business process, and the workflow engine can execute the flow, there is nothing in the model that enforces the expected flow. Therefore, users of the process may cause errors or other delays, which lead to process failures or other problems. One of the biggest obstacles for users of such software is when updates are made to the process (e.g., changing the order of tasks, removing or adding tasks, etc.) or to the user interface that affects input fields and other input mechanisms that are normally accessed by users. Such user interface changes may cause confusion and delays in data entry. In addition, errors often occur, resulting in delays and even failures. Many users will need training courses or third parties to help them recognize and use the updated user interface.

[0021] Example embodiments relate to a software system (also described herein as a host system) that can generate and output fully guided steps for data entry of a complex process. The host system can identify the current state of the process, for example, from a workflow engine that is executing / running an instance of the process. The host system can identify annotations within the process model based on the current state of the process to identify the required user interfaces and fields, and output the user interface in a manner that "guides" the user to the correct enterprise software system stored within the process model of the process and the appropriate user interface therein.

[0022] In some cases, the guided steps can be "completely" guided steps that prevent the user from needing to learn / understand any of the input elements, fields, field names, where the fields are located on the user interface, etc., because the user can rely on the software to show them exactly what data needs to be entered and where. Furthermore, when changes are subsequently made to the process or user interface, the user does not need to become familiar with those changes (e.g., by reading updated manuals, procedures, etc.). Instead, the system can simply update the process model / map to map the new process steps to the corresponding input element / user interface combinations, thereby guiding the user through the changes without the user even needing to know that those changes have occurred.

[0023] For example, a business process involving the sale of goods may include the requirement to create a sales order (document) identifying the goods and the requirement to generate and clear an invoice (document). In addition, the process may require a third document (receipt) to be sent to the purchaser. Each of these documents may require a different system and a different user interface. The host system described herein can navigate the user directly to the user interface and the field where the data needs to be entered. In addition, the system can provide a "guided" method for data entry by disabling or otherwise preventing the user from entering data or other inputs to any possible position on the user interface that accepts the field that requires data entry. Here, the system can hide or dim the inaccessible aspects of the user interface and highlight or otherwise visually distinguish the fields that require data entry. If the user encounters an abnormal situation, a switch such as a small lock symbol can be displayed in the user interface, allowing the user to unlock the rest of the user interface to also perform other changes when needed. Track these events to ensure a feedback loop with the process owner to allow such an operating procedure to be explicitly included in the next iteration of the business process model.

[0024] Figure 1 A computing environment 100 for generating and outputting a guided process execution of a complex business process according to an example embodiment is shown. Figure 1 , the host platform 120 hosts a system (host application 122) that can output a guided process execution on a user interface. For example, the host platform 120 can be a combination of a cloud platform, a web server, a database, a device, etc. Here, the host application 122 can identify which user interface of the target system needs to be displayed and which fields in the user interface need to be entered based on the current state of the process, and guide the user to enter the content into the identified fields on the specific user interface. For example, the host application 122 can generate a link, a uniform resource locator (URL), a batch command, etc. to summon the user interface of the target system. The link may include information that identifies which fields on the user interface are to be highlighted, etc. Once the user has entered the necessary input data, the process proceeds to the next step and removes the user interface from the screen. The fully guided input process can guide the user to enter data into specific input elements on the user interface, thereby creating a more efficient data input process.

[0025] For example, the host application 122 can identify the current position of the process from the process host 130 (such as a workflow engine). The host application 122 can identify the next activity to be executed based on the node, edge, or other portion of the process model 124 corresponding to the current position of the process. Here, the host application 122 can identify / read the annotation that has been embedded or otherwise incorporated into the graphical representation of the next activity within the process model 124, and identify the mapping 126 for the next activity. The host application 122 can map the activity to a user interface stored in a user interface (UI) repository 128 based on the mapping 126. In addition, the host application 122 can map the activity to a subset of user interface input elements on the user interface, such as fields, buttons, menus, radios, etc.

[0026] Next, the host application 122 may generate and send a notification to the user device 110 of the user responsible for the next activity to be performed. The user's information may be maintained within the process model 124 (i.e., a swimlane in BPMN) as part of a role that assigns responsibility for a particular task to a role such as "Accountant," or within other logic within the host application 122. As an example, the notification may be delivered to the user's "inbox," such as an email inbox, a process activity inbox, or the like. When the user clicks on the notification, the host platform may summon a specific user interface for the notification and output a fully guided user interface experience to the user device 110 via the specific user interface. Here, the host application 122 may navigate the view of the user interface 112 on the user device 110 to a subset of the fields on the user interface that require data entry, while preventing the user device 110 from entering data or other input to other areas of the user interface, such as other areas that include input fields that are not associated with the next activity.

[0027] The UI repository 128 can store a repository of user interfaces (e.g., screens, pages, etc.) from software applications used by complex business processes. The user interfaces can be uniquely identifiable and retrievable from the UI repository 128. The host application 122 can identify which UI to retrieve from the UI repository 128 based on annotations within the process model 124. For example, the annotation can be within a node corresponding to the next activity in the process model. In this case, the node can include an annotation stored therein (e.g., within the metadata of the model, etc.), which can be read by the host application 122 and used to identify a subset of user interfaces and input elements based on the mapping 126. In addition, the host application 122 can navigate the view of the user interface 112 directly to the identified user interface, where only a subset of input fields are available for access and input.

[0028] Figure 2AFIG. 2 shows a user interface 200 for annotating a process model using user interface elements according to an example embodiment. Figure 2A , the user interface 200 includes a display of a process model, such as a BPMN model. In this example, the process model includes a plurality of swimlanes corresponding to a plurality of participants (e.g., user roles) of the process, and activities to be performed by each different corresponding role displayed within the swimlanes. In this example, the three roles / swimlanes correspond to an "assistant" who receives an invoice via electronic means, such as email, an "approver" who reviews the invoice and determines whether to approve the invoice for payment, and a "manager" who revise the approval.

[0029] Figure 2A The process shown in includes five activities represented by five nodes in the schematic diagram, including a node 201 corresponding to a first activity, a node 202 corresponding to a second activity, a node 203 corresponding to a third activity, a node 204 corresponding to a fourth activity, and a node 205 corresponding to a fifth activity. The process also includes directed edges 210 between nodes that establish flows and dependencies between nodes 201, 202, 203, 204, and 205 of the process. Activities may involve different user interfaces, documents, data systems on the back end, etc. The process also includes decisions 212 and 214 that control the path of the process during execution.

[0030] According to various embodiments, the user interface 200 enables a user to add annotations, metadata, data values, etc. to a schematic diagram of a process model using input mechanisms such as a mouse, keyboard, voice activation, etc. In doing so, a user can generate mappings between user interfaces and activities, as well as user interface input elements from the user interface to the activities. The annotations can be read by a host application herein to identify mappings between activities within the process model and user interface elements required for inputting data into those activities of the process. In some cases, the annotations can include mappings in the process model. As another example, the mappings can be stored in a separate file created by the host application.

[0031] For example, Figure 2BFlow 220 is shown in which a user moves a cursor over a node 203 corresponding to an invoice modification activity within a process model and selects the cursor (e.g., clicks the cursor) using a pointer mechanism such as a mouse or finger. Here, selection of the node 203 corresponding to the third activity (modify invoice) causes the user interface 200B to display a menu 230 for adding annotations (e.g., mappings, etc.) to the process model. The menu may include user interface input elements (e.g., target enterprise software system, affected business document, field name, input button name, etc.) that allow the user to add or remove such input elements to activities within the process model. In doing so, the user can annotate the process model. The annotations may be detected by the host system and used by the system to create a mapping between specific activities within the process, user interface identifiers of the target system's user interface, and user interface field / input element identifiers on the user interface (such as Figure 2C 240 in the mapping table). Figure 2C The mappings shown in are for example purposes only and are not meant to limit the example embodiments. Annotations within the process model may identify additional attributes that may be stored in the mapping in the mapping table, including but not limited to identifiers of target systems, business documents, data model attributes, user interface options, etc.

[0032] For example, a user may use a cursor to select field 232 from a user interface associated with modifying an invoice associated with the activity. In response, the system may add an entry to mapping table 240 that creates a mapping between field 232 on the user interface and the activity corresponding to node 203 in the process model.

[0033] When real-time execution of the process instance subsequently occurs, the host system can identify the current state of the process instance to identify the next activity to be executed. In this example, the system can identify that the activity corresponding to node 203 in the process model is the next one. In this way, the system can identify the user interface / user interface fields required to enter data associated with the activity from the mapping table 240, and generate a guided user interface experience for the user. For example, the user's browser, application, etc. can be directly navigated to the user interface and the corresponding business document instance associated with the process instance that needs to be entered, as well as the fields that need to be entered.

[0034] The process model can be updated at any time throughout the life of the process. For example, the process model can be updated to remove comments, activities, paths, steps, etc. from the process model. When this happens, the mapping may also change. For example, the system can remove entries from the mapping in response to a user removing a field from the process model.

[0035] refer to Figure 2C, a mapping table 240 includes three columns 242, 244, and 246 corresponding to three attributes associated with the process, the three attributes respectively including an activity identifier identifying an activity (i.e., a node) within the process, a user interface identifier identifying a user interface required to input data into the activity, and a UI input element identifier identifying one or more user interface input elements for inputting data for the activity. The mapping table 240 can be read by a host system to identify which fields on which user interface are to be displayed for each activity in the process. Each user interface stored in the repository can have a different identifier associated with it, which is stored in a directory mapped to the storage location of the user interface in the repository. Therefore, the host application can use the user interface identifier annotated in the process model to retrieve the user interface from the repository based on the directory.

[0036] Figure 3 3 shows a process 300 for determining the next action of a process via a host application 320 based on the current state of the process provided by a workflow engine 310 according to an example embodiment. Figure 3 , the instance 302 of the process can be executed by a workflow engine 310. For example, the workflow engine 310 can analyze the process model (e.g., BPMN model, etc.) of the process and interpret the content of the BPMN model to execute the process. The workflow engine 310 can create a workflow for solving open, closed, and unfinished tasks in the instance of the process based on the current state of the process.

[0037] For example, the workflow engine 310 can run on both a time-based engine and a business rule engine, meaning that a rule can include a collection of logical conditions or can be initiated before a set time or deadline. In addition, multiple users can simultaneously perform a portion of a task related to their role via the workflow engine 310. Once a portion of a loop is completed, the workflow engine 310 can trigger differentiated notifications for the customer, sales executive, and administrator segments. Here, the workflow engine 310 can implement version control, and can perform user authentication to control access, state persistence, which frees up memory for long-term processes such as contract management.

[0038] According to various embodiments, the workflow engine 310 can track the current position of the instance 302 of the process based on the state of the workflow being executed. For example, if the workflow engine 310 detects that the first activity is completed, it can notify the host application 320. As another example, if the workflow engine 310 detects that the first activity is completed, it can notify the host application 320 of the next activity to be performed. Therefore, the host application 320 can identify the current state of the instance 302 of the process. Here, the host application 320 can refer to one or more of the annotated process model 322 and mapping 324 to identify the user interface, and the user input element from the user interface associated with the next activity. In addition, the host application 320 can generate a user interface / dashboard, which includes a user interface and a guided step for inputting data from the user interface into the identified user input element. Here, the guided step can be output to the user device 330 of the user on the user interface. As an example, the process can be executed based on the analytical capabilities of similar process mining of one or more target systems such as the ERP software system 340. Here, the ERP software system 340 may receive input to the process from the user device 330 and annotate the process model and / or execute mappings stored in a mapping table, such as Figure 2C As another example, the process may be executed in response to a hook on the user interface that notifies the workflow engine 310 and the host application 320 of a successful state change to the process instance 302 based on the user's action.

[0039] Figure 4A 400A shows an inbox view of items that require attention according to an example embodiment. Figure 4A , the user interface 402 may be displayed on a user device, such as Figure 3 The user device 330 shown. Here, the user can view tasks, emails, messages, etc. For example, the inbox 410 on the user interface can include a compressed summary of each waiting item / task in the inbox. Therefore, the user can see a summary of things waiting for their attention. The inbox can also be shared between multiple users sharing the same role to ensure continuity when someone is on vacation. In some embodiments, the host application 320 described herein can generate alerts included in the summary / compressed view in the inbox 410. In addition, the host application 320 can rearrange the items in the inbox 410 so that more urgent items are placed at the top of the inbox 410.

[0040] exist Figure 4AIn the example of , the user has selected item 412 from inbox 410. In response, a message corresponding to item 412 is opened in navigation area 420 of user interface 402. Navigation area 420 includes a message explaining the urgent item awaiting the user's attention, as well as a link 422 pointing to a guided UI experience. However, a link is not required. For example, simply clicking on item 412 can navigate the user directly to the guided UI experience without opening the message in navigation area 420. When the user clicks on link 422, the guided steps are generated by host application 320. For example, user interface 402 can be used on user device 330 to Figure 4B The user interface replacement shown in .

[0041] Figure 4B Flow 400B is shown of steps for providing guidance via user interface 402 according to an example embodiment. As an example, the guided steps may be referred to as "fully guided steps." In this example, the host system may guide the user to one or more specific fields where the user needs to enter data, and disable or otherwise prevent the user from entering data into other fields or areas of the user interface and application. Figure 4B In response to the user clicking on link 422 in navigation area 420 of the message, the host system can navigate user interface 402 to the user's fully guided experience.

[0042] For example, the host system may navigate to a view of invoice 430 corresponding to item 412. The host system may highlight, bold, underline, color, mark, etc., field 431 that requires data entry, and disable other fields and values ​​on the user interface, including fields and values ​​within content areas 432, 433, 434, 435, and 436. To disable content areas 432, 433, 434, 435, and 436, the host system may overlay dark or shaded content on top of them. As another example, the host system may remove items from the user interface, leaving only input elements that require entry. By navigating to the user interface, the system provides a "guided step" for data entry. Furthermore, by highlighting required input elements and disabling unnecessary input elements, the system may provide a "fully guided step" for data entry.

[0043] The fully guided steps prevent users from entering data into areas of the user interface and application where it is not needed. In addition, it prevents users from needing to learn / understand any of the input elements, fields, field names, where the fields are located on the user interface, etc., because users can rely on the software to show them exactly what data needs to be entered.

[0044] Figure 5A method 500 for generating and outputting a guided process execution according to an example embodiment is shown. For example, the method 500 may be performed by a software application hosted by a host platform such as a cloud platform, a web server, a distributed system, a database, etc. Figure 5 In 510, the method may include receiving runtime data of an instance of a software process from a workflow engine that is executing the instance of the software process. For example, the runtime data may include runtime data such as a current step being executed, a next step to be executed, etc. In some embodiments, the workflow engine may provide an identifier of the next step to be executed to a host system as described herein.

[0045] In 520, the method may include determining, based on the runtime data, a process activity that is expected to occur next within a running instance of the software process. In 530, the method may include identifying, based on annotations within a process model of the software process, a subset of input elements within a graphical user interface (GUI) and the GUI that are mapped to the determined process activity. In 540, the method may include highlighting the identified subset of input elements and disabling any remaining input elements within the GUI to generate a guided GUI. In 550, the method may include displaying the guided GUI via a computing system of a user.

[0046] In some embodiments, highlighting may include rendering a highlighted line around each input field in the subset of input fields, and disabling includes overlaying a darkened mask over the disabled remaining input elements within the guided GUI. In some embodiments, the method may also include displaying a schematic diagram of the process model via a user interface, and generating annotations within the process model of the software process based on input received via the schematic diagram of the process model displayed on the user interface. In some embodiments, identifying may include identifying the subset of input elements based on a mapping table of the process model, the mapping table including mappings between process activities, GUIs, and the subset of input elements.

[0047] In some embodiments, the method may further include receiving input to remove an activity from the process model, and in response, removing a mapping between the removed activity and one or more input elements from a mapping table of the process model. In some embodiments, receiving may include receiving an update on the state of the process instance from the workflow engine when the workflow engine executes the process instance in parallel. In some embodiments, the method may further include generating a notification for a user in response to determining that the process activity is expected to occur next, and sending the notification to an inbox of the user. In some embodiments, the method may further include displaying a fully guided GUI in response to detecting a selection of a notification in the user's inbox.

[0048] Figure 6600 is shown, which can be used in any of the methods and processes described herein, according to an example embodiment. For example, the computing system 600 can be a database node, a server, a cloud platform, etc. In some embodiments, the computing system 600 can be distributed across multiple computing devices, such as multiple database nodes. Figure 6 , the computing system 600 includes a network interface 610, a processor 620, an input / output 630, and a storage device 640 such as a memory storage. Figure 6 Although not shown in the figure, the computing system 600 may further include or be electrically connected to other components such as a display, an input unit, a receiver, a transmitter, a permanent disk, etc. The processor 620 may control other components of the computing system 600 .

[0049] The network interface 610 can send and receive data through a network such as the Internet, a private network, a public network, an enterprise network, etc. The network interface 610 can be a wireless interface, a wired interface, or a combination thereof. The processor 620 can include one or more processing devices, each of which includes one or more processing cores. In some examples, the processor 620 is a multi-core processor or multiple multi-core processors. In addition, the processor 620 can be fixed, or it can be reconfigurable. The input / output 630 may include an interface, port, cable, bus, board, wire, etc. for inputting data to and outputting data from the computing system 600. For example, data can be output to an embedded display of the computing system 600, an externally connected display, a display connected to the cloud, another device, etc. The network interface 610, the input / output 630, the storage device 640, or a combination thereof can interact with applications executed on other devices.

[0050] The storage device 640 is not limited to a specific storage device and may include any known memory device, such as RAM, ROM, hard disk, etc., and may or may not be included in a database system, a cloud environment, a web server, etc. The storage device 640 may store software modules or other instructions that can be executed by the processor 620 to perform the methods described herein. According to various embodiments, the storage device 640 may include a data storage with multiple tables, records, partitions, and sub-partitions. The storage device 640 may be used to store database records, documents, entries, etc.

[0051] According to various embodiments, the storage device 640 can be configured to store a process model of the software process. By way of example only, the process model can be a BPMN model, etc., which includes a flowchart of steps / activities performed during the process and a sequence / order of activities including dependencies. The processor 620 can receive runtime data of an instance of the software process from a host of the process (such as a workflow engine that executes an instance of the software process), and in response, determine the process activities that are expected to occur next within the instance of the software process based on the runtime data. For example, the workflow engine can identify which part of the process the current instance of the process is in.

[0052] The processor 620 may also identify a subset of input elements in the GUI mapped to the determined process activities and the input elements based on the GUI based on the annotations in the process model of the software process. The processor 620 may highlight the identified subset of input elements and disable any remaining input elements in the GUI to generate a guided GUI, and display the guided GUI via the user's computing system.

[0053] As will be understood based on the foregoing description, the above examples of the present disclosure may be implemented using computer programming or engineering techniques including computer software, firmware, hardware, or any combination or subset thereof. Any such resulting program having computer readable code may be embodied or provided in one or more non-transitory computer-readable media, thereby manufacturing a computer program product, i.e., an article of manufacture, according to the discussed examples of the present disclosure. For example, a non-transitory computer-readable medium may be, but is not limited to, a fixed drive, a disk, an optical disk, a tape, a flash memory, an external drive, a semiconductor memory (such as a read-only memory (ROM), a random access memory (RAM)), and / or any other non-transitory medium.

[0054] A computer program (also referred to as a program, software, software application, "app" or code) may include machine instructions for a programmable processor and may be implemented in high-level procedural and / or object-oriented programming languages ​​and / or in assembly / machine language. As used herein, the terms "machine-readable medium" and "computer-readable medium" refer to any computer program product, apparatus, cloud storage, Internet of Things, and / or device (e.g., disk, optical disk, memory, programmable logic device (PLD)) for providing machine instructions and / or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. However, "machine-readable medium" and "computer-readable medium" do not include transient signals. The term "machine-readable signal" refers to any signal that can be used to provide machine instructions and / or any other kind of data to a programmable processor.

[0055] The above description and illustration of the processes herein should not be considered to imply a fixed order for performing the process steps. Instead, the processing steps may be performed in any feasible order, including performing at least some steps simultaneously. Although the present disclosure has been described in conjunction with specific examples, it should be understood that various changes, substitutions and modifications that are obvious to those skilled in the art may be made to the disclosed embodiments without departing from the spirit and scope of the present disclosure set forth in the appended claims.

Claims

1. A computing system comprising: a storage device configured to store a process model of a software process; as well as The processor is configured as: receiving runtime data of the instance of the software process from a workflow engine executing the instance of the software process; determining, based on the runtime data, a process activity that is expected to occur next within an instance of the software process; identifying a subset of input elements within a graphical user interface GUI mapped to determined process activities and the GUI based on annotations within a process model of the software process stored in a storage device; highlighting a subset of the identified input elements and disabling any remaining input elements within the GUI to generate a guided GUI; and The guided GUI is displayed via the user's computing system.

2. The computing system of claim 1, wherein: The processor is configured to render a highlighted line around each input field in the subset of input fields and overlay a dimmed mask on the remaining input elements within the guided GUI that are disabled.

3. The computing system of claim 1, wherein: The processor is further configured to display a schematic diagram of the process model via the user interface, and generate annotations within the process model of the software process based on input received via the schematic diagram of the process model displayed on the user interface.

4. The computing system of claim 1, wherein: The processor is configured to identify the subset of input elements based on a mapping table of the process model, the mapping table of the process model including mappings between process activities, the GUI, and the subset of input elements.

5. The computing system of claim 4, wherein: The processor is configured to receive input to remove an activity from the process model, and in response, remove a mapping between the removed activity and one or more input elements from a mapping table of the process model.

6. The computing system of claim 1, wherein: The processor is configured to receive updates of the status of the process instance from the workflow engine when the workflow engine executes the process instance in parallel.

7. The computing system of claim 1, wherein: The processor is configured to generate a notification for the user in response to determining that the flow activity is expected to occur next, and send the notification to an inbox of the user.

8. The computing system of claim 7, wherein: The processor is configured to display a fully guided GUI in response to detecting a selection of a notification within the user's inbox.

9. A method comprising: receiving runtime data of the instance of the software process from a workflow engine that is executing the instance of the software process; determining, based on the runtime data, a process activity that is expected to occur next within a running instance of the software process; identifying a subset of input elements in a graphical user interface GUI mapped to determined process activities and the GUI based on annotations in a process model of the software process; highlighting a subset of the identified input elements and disabling any remaining input elements within the GUI to generate a guided GUI; and The guided GUI is displayed via the user's computing system.

10. The method according to claim 9, wherein: Highlighting includes rendering a highlighted line around each input field among the subset of input fields, and disabling includes overlaying a dimmed mask on the remaining input elements that are disabled within the guided GUI.

11. The method according to claim 9, wherein: The method also includes displaying a schematic diagram of the process model via the user interface, and generating annotations within the process model of the software process based on input received via the schematic diagram of the process model displayed on the user interface.

12. The method according to claim 9, wherein: The identifying includes identifying the subset of input elements based on a mapping table of the process model, the mapping table of the process model including mappings between process activities, the GUI, and the subset of input elements.

13. The method according to claim 12, wherein: The method also includes receiving input to remove an activity from the process model, and in response, removing a mapping between the removed activity and the one or more input elements from a mapping table of the process model.

14. The method according to claim 9, wherein: Receiving includes receiving updates on the state of the process instance from the workflow engine while the workflow engine executes the process instance in parallel.

15. The method according to claim 9, wherein: The method also includes generating a notification for the user in response to determining that the process activity is expected to occur next, and sending the notification to an inbox of the user.

16. The method according to claim 15, wherein: The method includes displaying a fully booted GUI in response to detecting a selection of a notification within an inbox of a user.

17. A computer readable medium comprising instructions which, when executed by a processor, cause a computer to perform a method comprising: receiving runtime data of the instance of the software process from a workflow engine that is executing the instance of the software process; determining, based on the runtime data, a process activity that is expected to occur next within a running instance of the software process; identifying a subset of input elements in a graphical user interface GUI mapped to determined process activities and the GUI based on annotations in a process model of the software process; highlighting a subset of the identified input elements and disabling any remaining input elements within the GUI to generate a guided GUI; and The guided GUI is displayed via the user's computing system.

18. The computer-readable medium of claim 17, wherein: Highlighting includes rendering a highlighted line around each input field among the subset of input fields, and disabling includes overlaying a dimmed mask on the remaining input elements that are disabled within the guided GUI.

19. The computer-readable medium of claim 17, wherein: The method also includes displaying a schematic diagram of the process model via the user interface, and generating annotations within the process model of the software process based on input received via the schematic diagram of the process model displayed on the user interface.

20. The computer-readable medium of claim 17, wherein: The identifying includes identifying the subset of input elements based on a mapping table of the process model, the mapping table of the process model including mappings between process activities, the GUI, and the subset of input elements.

Images