Automated project scheduling from UML sequence diagrams using OCR and critical path analysis

Abstract

This paper introduces a novel automated framework aimed at bridging the gap between software design documentation and practical project management schedules. The primary objective is to address the longstanding challenge of manually translating UML sequence diagrams, fundamental design artifacts in software engineering, into executable and accurate project management plans such as Gantt charts and precedence graphs. Current manual approaches to schedule generation are notably error-prone, time-consuming, and inadequately integrated with the dynamic requirements of Agile and iterative project environments. To tackle this critical research gap, the paper proposes an integrated methodological pipeline combining advanced Optical Character Recognition (OCR), dependency graph generation, and machine learning optimization techniques. Specifically, OCR is employed to automatically extract tasks, interactions, and temporal details directly from visual representations of UML sequence diagrams, significantly reducing transcription errors and saving valuable planning time. Following extraction, tasks are structured into a validated Directed Acyclic Graph (DAG), accurately modeling inter-task dependencies and constraints. Further enhancing scheduling accuracy, the study applies gradient descent methods to iteratively predict and optimize task durations, moving beyond static estimates to dynamically refined predictions based on real-world project constraints. A forward pass analysis then calculates the earliest feasible start times, while Critical Path Method (CPM) analysis identifies the tasks crucial for project completion timelines. Comprehensive experimental validation across diverse scenarios clearly demonstrates the effectiveness and reliability of the proposed framework. Results show notable improvements in scheduling precision, visualization clarity through8/ generated Gantt charts and precedence graphs, and offering practical benefits to project managers and software development teams.

Introduction

Use case diagrams and sequence diagrams are fundamental elements of the Unified Modeling Language (UML), each contributing uniquely to software modeling. Use case diagrams are used during the requirements analysis phase to depict the functional capabilities of a system and its interactions with external actors, enabling clear communication between stakeholders and developers¹. In contrast, sequence diagrams are employed to model the temporal flow of interactions among objects, capturing message ordering and system behavior in response to various use cases². The combination of both diagram types allows developers to move from abstract user goals to detailed implementation logic. As noted in recent studies, integrating use case and sequence modeling enhances the reliability of system design and supports automated validation and traceability throughout development workflows. In system analysis and software engineering, dependency graphs are vital tools for visualizing and managing the relationships between components, modules, or processes within a system. They help engineers understand how changes in one part of the system might affect others, which is essential for impact analysis, debugging, and maintenance. By mapping dependencies, these graphs support better modular design, allowing developers to isolate functions and reduce coupling between components. In software development, dependency graphs also aid in identifying redundant or outdated modules, optimizing build processes, and ensuring more reliable integration³. Based on the role of dependency graphs in system analysis and software engineering, Gantt charts and the Critical Path Method (CPM) serve as essential project management tools that integrate temporal and dependency-based information to enhance planning and execution. While dependency graphs model the structural relationships among system components or tasks, Gantt charts provide a temporal representation of project activities, delineating their sequence, duration, and potential concurrency⁴. CPM further refines this approach by identifying the longest chain of dependent tasks—known as the critical path—which governs the shortest possible project completion time. These methodologies are particularly valuable in software engineering for scheduling development workflows, optimizing resource allocation, and proactively managing risks associated with delays. When used in conjunction with dependency analysis, Gantt charts and CPM facilitate a comprehensive understanding of both the logical and temporal dimensions of project execution, thereby improving coordination, minimizing uncertainty, and supporting informed decision-making throughout the software development lifecycle⁵.

While research methodologies highlight the practical benefits of Gantt charts in managing project timelines, resources, and dependencies^6,7, it primarily discusses their use in a manual or semi-structured context. The study provides insights into how Gantt charts can support coordination and planning in complex project environments, yet it does not address how these charts can be automatically generated from early-stage software design models, such as UML sequence diagrams. This reveals a critical research gap; the lack of integrated, automated methodologies that transform software design artifacts into executable project management outputs. The contribution of the paper is presented as follows:

1. Proposes an automated pipeline to convert UML sequence diagrams into Gantt charts and precedence graphs.

2. Integrates OCR for task extraction from visual representations of sequence diagrams with start and end dates.

3. Constructs a validated dependency graph (DAG) from extracted tasks to model inter-task relationships.

4. Applies gradient descent to learn task durations dynamically, removing reliance on predefined estimates.

5. Performs forward pass analysis to calculate early task start times and determine scheduling feasibility.

6. Predicts the Critical Path using computational analysis of task dependencies and durations.

7. Outputs both Gantt charts and precedence graphs, enhancing visualization and planning accuracy.

Related work

The translation of software design artifacts into executable project plans remains a persistent challenge in software engineering. While UML sequence diagrams excel at modeling system behavior through temporal interactions, and project management tools like Gantt charts and CPM effectively track task schedules, these worlds remain stubbornly disconnected. Current approaches either rely on manual translation of design logic into schedules—a time-consuming and error-prone process⁶—or focus narrowly on structural dependencies while ignoring dynamic constraints like task durations³. This gap is particularly glaring in Agile environments, where rapid iteration demands tight coupling between design and planning. Recent advances in OCR and machine learning offer promising tools to bridge this divide, yet no existing solution integrates them into an end-to-end pipeline. Our work addresses this by proposing the first automated framework that extracts tasks from sequence diagrams via OCR, constructs optimized schedules using learned durations, and generates both Gantt charts and precedence graphs—effectively turning design blueprints into actionable project timelines.

Agile development and UML diagrams in modern software engineering

The authors of⁸ present a comprehensive examination of how Machine Learning techniques are transforming Model-Driven Engineering practices. Their systematic review of over 9,000 publications reveals that while MDE has become an established industrial paradigm for software development, its integration with advanced ML methods represents a significant emerging frontier. The authors of⁹ investigate real-world challenges in software modeling through a global survey of 80 practitioners. The study identifies and ranks eight key problem areas—from language complexity to model versioning—to understand why teams struggle with modeling adoption despite its theoretical benefits, ultimately providing actionable insights for improving tools and practices. In addition, the authors of¹⁰ address a critical gap in modern software engineering research by systematically linking Agile development practices with Big Data analytics. While both Agile methods and data-driven development have transformed the industry independently, this study provides the first comprehensive synthesis of their intersection. The authors of¹¹ examine the challenges of selecting agile methodologies for web projects through a systematic review of six development approaches. Researchers identify five key shared characteristics: flexibility, continuous team communication, UML usage, end-user involvement, and balanced documentation. The analysis reveals critical implementation gaps between theoretical benefits and real-world practice, helping project managers evaluate methodology suitability based on project needs, team capabilities, and client requirements.

UML diagrams serve as the blueprint language of software engineering, providing standardized visual representations of system design across all development phases. From use case diagrams capturing requirements to sequence diagrams modeling interactions and class diagrams defining architecture, UML bridges the gap between conceptual planning and implementation. The authors of¹² address the critical gap in UML model similarity analysis by proposing a novel approach specifically for use case models. While existing research focuses primarily on design models (e.g., class diagrams), this study develops a hybrid method combining graph neural networks and semantic analysis to enable accurate reuse and validation of requirements-level UML artifacts. Furthermore, the authors of¹³ conduct a systematic literature review to evaluate the adoption and application trends of UML diagrams in software engineering research over two decades. The study specifically examines which diagram types dominate practice and their primary use cases in the development lifecycle. As presented in¹⁴, a framework that combines transfer learning (VGG16, ResNet50, InceptionV3) and data augmentation is applied to classify six UML diagram types from a newly created dataset. While results demonstrate transfer learning’s effectiveness with scarce data, the study identifies ongoing challenges in achieving perfect accuracy, highlighting opportunities for future improvement in accessible SE education tools. The authors of¹⁵ address the persistent challenge of UML diagram comprehension in software engineering education by developing and validating a comprehensive catalogue of common student errors across eight UML diagram types. Through systematic analysis of student submissions, this work establishes empirical patterns in mistake frequency, correlation, and evolution to enhance both teaching strategies and learning outcomes. The authors of¹⁶ explore the practical impact of UML diagram utilization in software engineering education through a comparative study of student teams. The work examines three key dimensions: development efficiency (time), implementation accuracy (code correctness), and design comprehension, with particular focus on class diagrams’ role in bridging documentation and implementation.

Dependency graphs and DAGs in project planning

The importance of dependency graphs (DAGs) in project planning is to represent task dependencies and execution order clearly, enabling efficient scheduling and resource management. DAGs facilitate parallel task execution, minimize bottlenecks, and optimize project timelines by ensuring that dependent tasks are executed in the correct sequence.

As presented in¹⁷, the authors addressed the scheduling of dependent data flows in multi-stage data-parallel computing tasks, structured as Directed Acyclic Graphs (DAGs). They proposed an approximation algorithm designed to minimize the total weighted completion time for these jobs in shared data centers. In addition, the authors of¹⁸ introduced DAG-Plan, an advanced planning framework tailored for dual-arm robots. In contrast to traditional linear planning approaches, DAG-Plan utilizes large language models (LLMs) to break down tasks into sub-tasks organized within Directed Acyclic Graphs (DAGs). This structure supports dynamic and adaptive assignment of actions to each robotic arm, allowing simultaneous execution of multiple tasks. The authors of¹⁹ proposed a multi-objective optimization model for Scrum sprint planning aimed at maximizing sprint capacity, prioritizing critical user stories, and grouping related tasks efficiently. It also considers alternative user stories, a novel addition. The model is tested using two heuristic algorithms, NSGA-II and SPEA2, on real-world datasets.

Automated project scheduling (Gantt/CPM)

The significance of project plan in organizations is considered an important methodology as a standardized tool for communication, information exchange, analysis, and evaluation. The authors of²⁰ reviewed various project management methodologies, outlining key components such as work breakdown structure, resource allocation, and budget planning, supported by practical examples. Additionally, they emphasize the importance of a well-structured communication plan for successful project execution. In addition, Gantt Charts is considered as a project management tool that visualizes activities as horizontal bars on a timeline, representing their start, end, and duration. It highlights their clarity in displaying project schedules but notes their inability to show task dependencies or the impact of delays²¹. The authors of²² optimized the scheduling of project tasks under resource limitations to minimize total project completion time. Gantt charts play a crucial role by visually mapping task timelines, resource allocation, and project progress. They help project managers track the effects of optimization techniques like Particle Swarm Optimization (PSO) and Linear Programming (LP), highlighting changes in task durations and dependencies. The authors of²³ explore the advancements and challenges in automating construction planning and scheduling over the past three decades. They highlight innovations in work scope development, project sequencing, and work breakdown structures while identifying key barriers to widespread adoption, such as rigid templates, limited learning from past projects, and insufficient real-world validation. In the context, Gantt charts are emphasized as vital tools for visualizing project timelines, tracking task sequences, and managing resource allocation, serving as a bridge between automated planning methods and practical project management. As proposed in²⁴, the authors explore and address the limitations of the classical Resource-Constrained Project Scheduling Problem (RCPSP) by examining its various extensions. The study aims to provide a comprehensive overview of how the standard RCPSP model has been adapted to better reflect real-world complexities, such as multi-project environments, resource flexibility, and dynamic project conditions.

As presented in²⁵, the critical path method (CPM) was applied to understand which project tasks are most crucial for meeting deadlines. By identifying these key activities, the company could focus on where delays might happen and take action to prevent them. Along with a What If Analysis, the team explored ways to speed up certain tasks, like adding more workers or increasing work hours, to stay on schedule even if setbacks occurred. The approach helped the company manage its projects more smoothly and avoid financial losses from late completions. In addition, the authors of²⁶ optimized the construction of two-floor houses by integrating the Critical Path Method (CPM) with multi-skilled labor to reduce worker numbers and increase resource utilization. Using Arena simulation software, different workforce strategies were compared, showing that multi-skilled workers required fewer personnel and had lower idle costs compared to single-skilled workers, highlighting the efficiency of multiskilling in construction projects. As presented in²⁷, the authors proposed an efficient search method for the Permutation Flow Shop Scheduling Problem (PFSP) using the Critical Path concept and three supporting theorems. A new neighborhood search technique is introduced, significantly reducing the search space and improving computational efficiency.

Applying OCR in model-driven engineering

The role of OCR (Optical Character Recognition) is to automate the transformation of visual elements into digital formats, improving efficiency and accessibility in various domains. It enables the digitization of hand-drawn business process diagrams, enhances the detection of elements in multi-domain models, streamlining development and project management processes.

As presented in²⁸, the objective of OCR is to automate the conversion of hand-drawn business process diagrams into digital formats. Using machine learning with TensorFlow, the research demonstrates the ability to accurately recognize standardized process elements, streamlining the digitization process and enhancing business process management efficiency. In Addition, the authors of²⁹ established a unified approach for detecting elements in multi-domain models within model-driven engineering using OCR. Google Cloud Vision and Microsoft Cognitive Services were tested for text detection, with Google Cloud Vision showing better results but facing issues with multi-line text recognition. To address this, the researchers developed Xamã, which enhanced text detection accuracy and outperformed the existing tool img2UML in identifying elements within the models. Finally, the authors of³⁰ enhanced Model-Driven Web Engineering (MDWE) by leveraging OCR and Deep Learning to automate code generation from wireframes, making web development more accessible to non-technical users and accelerating project timelines. This aligns with the role of Project Management, which focuses on optimizing resources, improving efficiency, and ensuring timely project delivery. By reducing manual coding and involving a broader range of contributors, this approach streamlines development phases, enhances collaboration, and minimizes bottlenecks.

Methodology

As presented in Fig. 1, the presented methodology outlines an automated process for transforming UML sequence diagrams into Gantt charts and precedence graphs, enabling efficient project planning and visualization. This structured approach bridges the gap between software design and project management by leveraging OCR, dependency graph generation, and machine learning techniques to optimize task scheduling and execution.

Fig. 1.

Automated conversion of UML sequence diagrams to Gantt charts and precedence graphs.

The first step involves creating an UML Sequence Diagram to show how different parts of the system communicate and the order in which tasks are performed. The diagrams are transformed into image formats in which each step or action is marked with its associated start and end times. This conversion readies the visual elements for automatic processing by machines in the following stages. After transforming the sequence diagrams into images, Optical Character Recognition (OCR) is used to identify the tasks and their associated information such as names, start dates and end dates. Automation of the process reduces the risk of errors and saves time when recording important project information. Based on the extracted tasks, a Dependency Graph is constructed to illustrate how tasks are interconnected and the order in which they must be completed. The graph is verified to meet the criteria of a Directed Acyclic Graph (DAG), guaranteeing that no task dependencies create loops that could interfere with the orderly execution of the project.

The next step involves computing the total duration of each task from its start date to its end date, providing a clear view of the required time span for each activity. Following this, the methodology employs Gradient Descent, a machine learning optimization technique, to iteratively learn and adjust task durations based on historical data and project constraints. This step improves scheduling accuracy by dynamically refining the estimated task durations. Once task durations are finalized, a Forward Pass analysis is conducted using the dependency graph to determine the earliest times at which each task can begin and end. It allows selecting the most efficient order for task execution, reducing gaps and maximizing productivity. Then, the Critical Path Method (CPM) is used to find the longest chain of tasks that sets the shortest project completion time. These tasks are essential and delaying any of them will prolong the entire project.

The result of the methodology is the creation of two crucial project management tools. A Gantt chart and a Precedence Graph are the two artifacts produced by the methodology. A Gantt Chart shows the distribution of activities, their durations and how they relate to each other through time, while a Precedence Graph illustrates the order in which tasks must be completed. Project managers can use these visualizations to create, track and fine-tune project schedules more effectively.

To comprehensively evaluate the efficiency and interactive capabilities of the proposed methodology, the subsequent procedural steps are meticulously delineated, providing a structured analysis of each phase within the transformation pipeline.

UML sequence diagram

The methodology begins with a UML Sequence Diagram which visually illustrates how different elements of the system communicate with each other throughout their lifecycles. However, sequence diagrams often do not specify the timing or dependencies necessary for constructing an effective project schedule. Consequently, additional temporal and execution-related details need to be incorporated into the sequence diagram in subsequent phases.

Although UML sequence diagrams capture message ordering and causality between lifelines, they typically do not encode absolute time, task durations, or the quantitative information required to compute an executable schedule. Moreover, in many workflows the diagram circulates only as a raster/PDF image without machine-readable semantics. To address both conditions, we adopt a modular ingestion layer that either (i) parses the native model (e.g., XMI) when available or (ii) applies OCR to rasterized diagrams to recover message labels and lane structure.

A semantics-preserving mapping then aggregates messages and combined fragments (e.g., alt/opt/loop; synchronous/asynchronous calls) into CPM activities with precedence constraints. Because durations are rarely specified at design time, we employ AI-assisted duration estimation constrained by a project-level time window, enabling the computation of ES/EF/LS/LF, total slack, and the critical path via CPM. In this way, the pipeline complements UML’s qualitative behavioral semantics with the quantitative elements necessary to yield a practical, analyzable project schedule, while keeping OCR strictly optional when the underlying model is available.

Convert sequence diagram to images with start and end dates

In this step, the UML Sequence Diagram is transformed into an image and the essential project parameters, namely the global start date and end date, are marked or displayed. The project must be completed between these two dates. Early determination of the project timeframe sets the groundwork for unchangeable parameters and ensures that subsequent adjustments to task durations are both practical and in line with actual project deadlines. This step is explained in formulas (1) and (2).

1

2

OCR task extraction (using EasyOCR)

EasyOCR is used to automatically identify and extract tasks, interactions and sequencing details from the sequence diagram image. The OCR tool automatically extracts textual information on objects and their interactions from the image. Every interaction is identified as a potential task, along with its sender and recipient details, guaranteeing uniformity and avoiding human transcription mistakes. The extracted tasks are used as the primary source for creating the graph as explained in formula (3).

3

where = label / message - = sender - = receiver - = order number.

We operate OCR as a pluggable ingestion front-end to the myriads of real-world situations in which sequence diagrams are only available like raster/PDF exports, report screenshots, or scanned whiteboard drawings, i.e., when no UML model is available. OCR is used in these contexts to obtain a tool-agnostic pipeline, meaning to recreate message text and lane structure, which is followed by layout clustering and message-grouping policies to extract the CPM activities and predecessors. We respond to the reliability problem in two senses: (i) we transmit OCR confidence scores and demand human verification of low-confidence spans; (ii) we check the extracted graph against simple structural properties and indicate violations to be examined. Notably, our implementation can completely skip OCR and just import the model (e.g., XMI) and execute the same transformation and CPM analysis, thereby being fully compatible with a traditional Model-Driven Engineering (MDE) process.

To better align the method with our stated goal—deriving an executable project schedule from early behavioral specifications—we refine the methodology with precise, justified design choices. First, we formalize a model-to-model transformation from sequence-diagram constructs (lifelines, messages, (Alt/Opt/Loop/par fragments) to a precedence DAG with typed constraints () that is suitable for CPM analysis. Second, we adopt a modular ingestion layer: when the native UML model is available we bypass OCR and parse semantics directly; OCR is used only for raster/PDF artifacts to ensure applicability in practice. Third, because sequence diagrams rarely contain durations, we estimate non-negative activity durations under an explicit objective that penalizes deviation from a project-level window while regularizing implausible values, after which CPM yields ES/EF/LS/LF, slack, and the critical path. Finally, we report ablations on ingestion mode, OCR confidence thresholds, and duration-learning hyperparameters, together with a brief complexity and limitations note, demonstrating that the transformation is reproducible, the analysis scales linearly with graph size, and the critical path is stable under moderate perturbations. Collectively, these clarifications make the approach precise, reproducible, and commensurate with the automation objective.

Model transformation specification ()

We formalize the transformation from UML sequence-diagram constructs to a precedence Directed Acyclic Graph used by CPM and to the rendered Gantt chart. Each vertex represents a CPM activity with attributes {name, sender, receiver, lifelines, fragment_scope, duration}. Each edge encodes a precedence relation with type and optional.

Lifelines: Lifelines are preserved as resource/lanes metadata. In the Gantt chart, activities inherit the lane of their dominant lifeline.

Messages: Each message becomes an activity named from its verb–object label. Along a given lifeline, the visual left-to-right/top-to-bottom order induces Finish-to-Start () edges to preserve local sequencing. For synchronous calls (with return), the caller’s next message receives an FS edge from. For asynchronous signals, we add a Start-to-Start () edge from the sender’s subsequent activity to to reflect that the sender can proceed without blocking; when the diagram explicitly shows a handler on the receiver, connects the sender’s post-send to the receiver’s handler activity. Explicit timing notes on a message are translated to edge or fixed durations when annotated.

Interactions/events: Creation/destruction events introduce start/terminal nodes on the affected lifeline; outgoing edges originate at creation and incoming edges terminate at destruction. Time constraints or delay notes become on the corresponding edges or minimum start times for the target activity.

Combined fragments:

• Alt: we build branch-local subgraphs guarded by the fragment’s conditions; an entry decision node fans out to each branch, and an rejoins successors. When probabilities are unknown, CPM uses the longest-branch duration for make span; alternative scenarios can be evaluated separately.

• Opt: modeled as an Alt with one empty branch.

• Loop: if an iteration count (or range) is present, the activity duration becomes; otherwise a parameterized multiplier is used and reported. Internal ordering is preserved by edges.

• Par: parallel operands are expanded as concurrent branches whose successors meet at an AND-join; no inter-branch precedence is added unless shown.

The precedence DAG GGG feeds CPM to compute, total slack, and the critical path. The Gantt chart renders each activity on the lane of its mapped lifeline with CPM start/finish times; critical-path activities are highlighted and alt/par structures are annotated at their entry bars. This specification makes the mapping from diagrammatic semantics to scheduling artifacts explicit and reproducible.

Generate dependency graph (using NetworkX)

The extracted activities are converted into a precedence (dependency) graph in which each node represents a task and each directed edge encodes that one task must precede another, optionally with a typed relation () and as defined by our mapping rules. Edges are generated from visual/message order, synchronous vs. asynchronous calls, and combined fragments (alt/opt/loop/par). The resulting graph is required to be a directed acyclic graph (DAG); we detect and reject cycles that indicate inconsistent constraints. Given a DAG, NetworkX provides topological sorting, reachability queries, and longest-path/critical-path computations used by CPM to obtain and slack. The formal definition of the graph follows in Eq. (4).

4

where denotes that task must precede task. By construction is a directed acyclic graph (DAG), enabling topological ordering and CPM computations.

Validate DAG (no cycles)

In the dependency graph a directed path of length is a sequence with for all. A self-loop is an edge ( A directed cycle is a directed path with whose first and last vertices coincide. For CPM to be well-defined, the dependency graph must be acyclic: we forbid self-loops and all directed cycles. The formal acyclicity constraints are given in Eq. (5).

5

Compute total days (start to end date)

Based on the global start and end dates, the total number of available project days is calculated. This value becomes the reference for learning task durations, ensuring that the final scheduled project does not exceed its assigned timeline. It creates a hard constraint that the learning algorithm must satisfy. This is explained in formula (6).

6

Predict task duration using gradient descent

Since no initial durations are provided for tasks, a learning process is implemented. A loss function is defined based on the deviation of the predicted project duration from the available total days. Gradient descent optimization is applied to iteratively adjust each task’s duration, reducing the overall error. This dynamic adjustment ensures that task durations are learned systematically to fit real-world project constraints as shown in formula (7) and (8).

7

where is the loss function.

8

Forward pass

The forward pass computes the earliest times that each task can start and finish without violating the dependency graph as explained in formula (9) and (10). It processes tasks sequentially, ensuring that no task starts before all its predecessors are finished. This step is fundamental to initial schedule creation. Let denote the set of immediate predecessor tasks of (i.e., tasks that must finish before can start).

9

10

Predict critical path method

After the forward pass, the backward pass is then conducted to calculate the Late Start (LS) and Late Finish (LF) times. Tasks that have no slack (when LS is equal to ES) are on the critical path which influences how long the entire project takes to complete. Determining the critical path plays a crucial role in both project management and risk assessment.

11

12

13

Generate Gantt chart

Gantt charts provide a graphical overview of the completed project schedule when task-level times have been generated by the Critical Path Method (CPM). Consider a directed acyclic graph (G = (V, E)) and, for each task (I ∈ V), its earliest start (ES_i) and duration (d_i > 0), the chart renders one horizontal bar per task spanning, making start/finish windows, overlaps, and potential resource congestion immediately apparent. Algorithm 1, formalizes this transformation: it traverses the task set, computes each earliest finish (EF_i = ES_i + d_i), maps times to chart coordinates, and draws the corresponding bars; optionally, it overlays precedence links for readability and annotates slack/criticality—e.g., highlighting tasks with total float (TF_i = 0) to emphasize the critical path—while aggregating per-period workload indicators to flag intervals of possible resource over-allocation. This is an algorithmic rendering that makes the Gantt chart not only illustrative but also a faithful, auditable projection of the CPM results that are appropriate to track, communicate, and perform what-if analysis.

Algorithm 1 GANTT-FROM-CPM: model generation of a Gantt chart from CPM outputs.

Generate precedence graph

The dependency graph is also visualized to offer a clear understanding of task dependencies and sequence relationships. This network diagram complements the Gantt chart by highlighting structural project logic rather than just timelines.

Experimental results and discussion

To ensure that the UML experts do not find it ambiguous, we use standard terminology of UML sequence diagrams and clearly explain how we map to CPM artifacts. An interaction in UML is the scenario-level container that owns lifelines, messages, and mixed fragments; it is not a task. The interaction in our pipeline represents the entire scenario of analysis. The activities/tasks represented in the dependency table and CPM graphs derive abstractions that are created by grouping semantically related messages between lifelines. Precedence edges are a result of message-level causal order and fragment guards: direct precedence on synchronous calls, happens-before on asynchronous messages, conditional branches on alt/opt guards, repeated predecessors on loop frames, and merge points on rejoining fragments. In this way, these message-related activities are represented by nodes in our CPM/precedence graphs, and the red critical path indicates one of the zero-float chains in the interaction. We thus use, instead of the previous expression, an interaction that is mapped to a task: every UML interaction is the scenario container; tasks are activity abstractions of grouped messages in that interaction.

Proposed system hyperparameters

The model sets specific hyperparameters to influence learning and displaying the results on Table 1. The number of epochs is chosen as 2000 to control how much gradient descent is executed while the algorithm is being trained. The value of `lr` (learning rate) helps to determine how large the changes are to weights during the convergence process. A fixed seed value of 42 is used in the spring_layout function to ensure consistent and reproducible graph visualizations. Setting k to 3.0 changes how the nodes are spread out in the dependency graph. The user enters dates for the project start and the project end, which helps determine how long the total project will last. Our case study date duration 120 days start from 01-04-2025 into 30-07-2025 for all scenarios discussed in this paper.

Table 1.

Hyperparameters of proposed model.

Hyperparameter	Value	Description
epochs	2000	Number of iterations for the gradient descent during duration learning.
lr (learning rate)	0.005	Step size used in gradient descent for updating task durations.
seed	42	Random seeds are used in spring_layout for reproducible graph visualization.
k (layout scaling)	3.0	Distance scaling parameter in spring_layout for graph drawing.
project_start	“2025-04-01”	Start date of the project.
project_end	“2025-07-30”	End date of the project.

The following three scenarios are retained because they instantiate canonical interaction patterns—request/response, branching (Alt/Opt), parallelism (Par), and iteration (loop)—that commonly appear in engineering projects. To make their project-management relevance explicit, we taskize each scenario: messages and combined fragments are mapped to deliverable-oriented activities with owners, precedence (), and (when unspecified) AI-assisted duration estimates. The resulting precedence DAG feeds CPM to compute, slack, and the critical path, and activities are rendered on a Gantt chart by responsible role/team. This makes each scenario directly actionable as a mini work-breakdown with dependencies and milestones, without changing the underlying methodology.

Scenario 1: health appointment scheduling and cancellation process

Figure 2 shows how a patient, a system, and a receptionist interact when scheduling and possibly cancelling a health appointment. First, the patient asks for an appointment form, and the system delivers it. As soon as the patient submits an appointment request, the system verifies the details, notifies them of the creation of a new one, and confirms the booking. Should the patient decide to cancel the appointment in the future, they submit a request, and the system looks into their eligibility. When the system checks that the patient meets the criteria for cancellation, it confirms the cancellation and informs the patient. Along with this process, the receptionist is responsible for viewing appointment requests, handling cancellations, and contacting doctors with schedules. The entire process, from booking to confirming and even canceling, is included in this scenario.

Fig. 2.

Scenario1 sequence diagram.

Scenario 1 results

Table 2 shows the order and duration of tasks needed in managing a healthcare appointment. Every row presents a task, the tasks that need to be done first (previous tasks), and the estimated number of days to accomplish the task (duration). The patient and the system receptionist are considered independent because they both initiate actions. The other tasks, including Display Form Appointment, Cancellation Confirmed Schedule, and Notify New Appointment Cancel, have to wait until the Patient System Receptionist task is finished. Likewise, actions related to patients (such as Schedule an Appointment and Request to Cancel) are handled by the Patient task. Book Receptionist plays a key role, as you first need to complete four other tasks before moving ahead. The process for Appointment and Doctor collects several dependencies, showing the outcome of earlier office and patient interactions. These durations help with organizing and planning for each task in the project.

Table 2.

Scenario 1 dependency table.

Task	Previous tasks	Duration (days)
Patient system receptionist	–	5.50
Patient	–	9.55
Display form appointment	Patient system receptionist	7.99
Cancellation confirmed schedule	Patient system receptionist	8.44
Verify eligibility appointment	Patient system receptionist	8.22
Notify new appointment cancel	Patient system receptionist	8.57
Request to cancel	Patient	9.27
Approve cancellation	Patient	8.19
Request appointment form	Patient	9.72
Submit appointment details	Patient	9.28
Booking confirmation	Patient	9.12
Book receptionist	Display form appointment, cancellation confirmed schedule, verify eligibility appointment, notify new appointment cancel	3.52
Cancel	Book receptionist	4.81
View	Book receptionist	7.59
Appointment	Request to cancel, approve cancellation, request appointment form, submit appointment details, booking confirmation, book receptionist	3.47
Doctor	Book receptionist	6.75

The identified critical path from Patient System Receptionist → Notify New Appointment Cancel → Book Receptionist → View shows the longest connected sequence of jobs that decide how long the project will take. Identifying and completing these steps on schedule will prevent your entire appointment scheduling workflow from being delayed. The first phase is handled by the patient system receptionist, who initiates processes that follow. After that, the process moves on to Notify New Appointment Cancel, which alerts needed staff about alterations in appointments. This journey consequently leads to Book Receptionist, a crucial role involving all scheduling tasks, and then View, which could involve checking or reviewing the appointments. Since tasks are dependent and must be finished promptly, any unfathomable delay will result in a setback in the schedule. Based on the project’s start and end dates, the total duration of the critical path is calculated to be 25.2 days.

On the Gantt chart shown in Fig. 3, each bar that moves horizontally means a given task, with the area below it showing when it was scheduled and how many days it took. With tasks like “Patient” and “Patient System Receptionist” kicking off the process at the very beginning, tasks like “Display Form Appointment” and “Notify New Appointment Cancel” can follow around day 5. Different tasks are completed simultaneously, which helps reduce the time required for the entire project. Notifying the client about an appointment cancellation, reserving the receptionist, viewing the details, and consulting with the doctor to make up the critical path, which can influence the duration of the entire project if anything is delayed. According to the chart, the project covers close to 25 days, finishing with the tasks “Doctor” and “View.” This Gantt chart clearly shows the order of tasks, as well as their lengths and the progression of the entire project.

Fig. 3.

Scenario 1 Gantt chart.

Figure 4 shows a precedence graph for a project annotated with CPM metrics, with a start and finish () node shaded to represent the total float () of each node. The graph starts at patient () and extends to front-end tasks (e.g., Request Form, Booking Confirmation, Submit Details) running in parallel, and then back to Appointment (17.38→23.12). The flow then moves there to late-stage alternatives, with the red chain Appointment → Patient System Receptionist → Book Receptionist → Cancel being critical: Book Receptionist (38.40 → 46.69) and Cancel (46.69 → 58.10) have (); hence, any delay will be passed on one-to-one to the project finish (makespan (= 58.10)). Noncritical branches (e.g., Verify Eligibility, View, Doctor) are positive (dark blue), i.e., have schedule flexibility to level the resources without impacting the completion.

Fig. 4.

Scenario 1 precedence graph.

Activities (owner → activity).

1. Reception → Define appointment intake workflow (FS → 2).

2. IT → Configure scheduling service & time-slot rules (FS → 3).

3. Backend → Implement booking API & validation (par with 4).

4. Frontend → Implement booking UI & error handling (join before 5).

5. QA → End-to-end tests for booking flow (FS → 6).

6. Ops → Deploy booking feature & announce availability.

Scenario 2: course registration and management in an academic information system

In the academic system shown in Fig. 5, the sequence diagram reflects how students, teachers, and administrators register for courses. At the beginning, the system registers the student in the course and then collaborates with the faculty to open the course and approve it. The student is able to review the schedule after it has been set. Should the students decide not to take the course, the system updates the number of students included in the faculty’s records. The list of students is managed and approved by faculty members. Administrators handle different procedures, including joining new users and setting up various educational terms. This demonstrates the way that all parties collaborate to run an online course.

Fig. 5.

Scenario 2 sequence diagram.

Scenario 2 results

In Table 3, the dependency table displays the order and length of academic tasks for managing a course, along with the tasks that should be completed first. The process starts with simple tasks that do not need any previous actions, such as looking at the schedule and registering for classes. They result in the following tasks, such as “Student System Faculty Admin,” “Open Course,” and “Manage Roster,” which all depend on the first tasks as well. Doing “Drop Course Configure Term” and “Approve Enrollment” also requires these essentials. Different set-up steps, both from the administrative area and related to the course, impact on the term configuration, while the ending task, managing users, is only possible after all other major tasks are completed. The process underscores that, for most functions, the order and timing depend on what happens in initial actions.

Table 3.

Scenario 2 dependency table.

Task	Previous tasks	Duration (days)
View schedule	–	13.37
Register for course	–	15.55
Student system faculty admin	View schedule, register for course	16.93
Open course	View schedule, register for course	16.55
Manage roster	View schedule, register for course	13.58
Drop course configure term	View schedule, register for course	5.00
Approve enrollment	View schedule, register for course	15.32
Configure term	Student system faculty admin, open course, manage roster, Drop course configure term, approve enrollment	5.40
Manage users	Student system faculty admin, open course, manage roster, drop course configure term, approve enrollment	18.29

In this case, the crucial sequence of related tasks determining the minimum project length is “Register for Course,” “Student System Faculty Admin”, and “Manage Users”. Faculty administration activities are made possible because course registration is the first basic step. After organizing the student system and administrative part of the faculty, the managing of users becomes the final major step. As these tasks are crucial and have the slowest completion time (50.8 days with no slack), if they are delayed, it will delay the entire project.

The Gantt chart displayed in Fig. 6 outlines the timeline for the tasks in a course management system and makes it easy to see the starting time and length of each task compared to the entire project. A horizontal bar for every task is drawn, with how long the bar represents its duration and where it is placed on the timeline indicating the starting point. Likewise, activities that are basic, such as viewing the schedule or registering for courses, are introduced right away, whereas other tasks, like those for faculty or managing students and courses, are carried out after the first phase is complete. “Set Up Term Dates” and “Manage Users” come up toward the end, as they depend on previous parts of the process. Managing users is the final step and adds the most time to the project, as demonstrated in the critical path analysis. Thanks to this Gantt chart, stakeholders easily identify task order, tasks that are worked on together, and potential delays, which aids in preparing the schedule and allocating resources.

Fig. 6.

Scenario 2 Gantt chart.

The precedence graph is annotated using CPM of Scenario 2 is shown in Fig. 7 with a node shown as asking earliest/latest times (ES, EF, LS, LF) and shading used to indicate total float (TF = LS-ES = LF-EF). Edges are red, indicating the presence of a critical path (CP). This flow begins with two parallel inputs, View Schedule (ES = 0.00, EF = 16.45,TF = 0) and Register for Course (0.00→11.74,TF = 4.70), which flow into a mid-layer of concurrent academic/administrative activities, Open Course (16.45→28.53,TF = 6.83); Manage Roster (16.45→33.98, The network is further narrowed on Student System Admin (ES = LS = 16.45, EF = LF = 35.37), and the result of the network is the project makespan, which equals 51.77 time units. The CP, therefore, is View Schedule → Student System Admin → Manage Users; any delay in this chain leads to one-to-one completion, which implies a late-stage administrative bottleneck. On the other hand, non-critical activities have positive float, so resource leveling through deferring Configure Term (TF = 9.56) or Drop Course Configure Term without schedule impact is possible, but attention and risk management must focus on Student System Admin and Manage Users, where the slack is zero and the schedule sensitivity is greatest.

Fig. 7.

Scenario 2 Precedence Graph.

Activities (owner → activity).

1. Registrar → Design course-eligibility rules (FS → 2).

2. Backend → Implement enrollment API & prerequisite check (par with 3).

3. DBA → Create/alter tables for enrollments & caps (join before 4).

4. Backend → Implement waitlist & notification service (FS → 5).

5. QA → Integration tests for enrollment/waitlist (FS → 6).

6. Ops → Release & monitor peak-load behavior.

Scenario 3: human–IoT interaction in a smart parking management system

In Fig. 8, we can see the relationship between a driver, parking officer, parking operator, IoT sensor system, and the system administrator. Parking operators first need to look for a space to park. The parking officer ensures that locations are protected and administers parking zones in a similar way to a system admin. The parking operator receives feedback from the IoT sensor system after displaying the status and confirming payments. Ultimately, the system admin checks system logs to ensure everything works properly. As shown by the diagram, people and machines work together to ensure parking is done properly.

Fig. 8.

Scenario 3 sequence diagram.

Scenario 3 result

Table 4, the tasks are identified, and you can see what depends on each task and the number of days it is expected to take. You can start tasks such as “configureZones” and “searchParkingSpot,” as they do not depend on other tasks. For the “reserveSpot” task to work, both of the other two tasks have to be finished, which means they act as a synchronization point. Next, to complete the “Jriver Parking Officer Parking IOT Sensor System,” the system must wait for rules in the “reserveSpot” task. After that, “updateStatus” is necessary since the tasks “validatePayment,” “configure Zones,” “monitorSystem Logs,” and “Operator System Admin” are all triggered by it. In this structure, the process is like that in a smart parking system: first, having set up and interacted with users, then updating the sensors, making sure everything is valid, and finally, administration is in charge of monitoring the system. The timeframe each task is expected to take is recorded in the durations, and the dependencies will point out the main route and any possible obstructions in the system’s setup or usage.

Table 4.

Scenario 3 dependency table.

Task	Previous tasks	Duration (days)
configureZones	–	19.45
searchParkingSpot	–	9.81
reserveSpot	searchParkingSpot, configureZones	6.87
Jriver Parking Officer Parking IOT Sensor System	reserveSpot	16.75
updateStatus	Jriver Parking Officer Parking IOT Sensor System	6.53
validatePayment	updateStatus	10.35
configure Zones	updateStatus	17.39
monitorSystem Logs	updateStatus	17.11
Operator System Admin	updateStatus	15.74

The longest chain of connected tasks in the project is the critical path, which consists of configureZones → reserveSpot → Jriver Parking Officer Parking IOT Sensor System → updateStatus and determines that the project will finish in 67.0 days. The steps covered include preparing parking zones, reservation processes, integrating IoT sensors, providing live information about the parking system, and making the final configuration due to these updates. As all these tasks have zero slack, any delay in one stage will lead to a delay in the entire project, so it is necessary to finish each part on schedule.

Figure 9 shows a Gantt chart helps us understand the timeline for every task and also shows when the project was started. At the start, tasks like configureZones and searchParkingSpot are used, and these are followed by other tasks like reserveSpot and the Jriver Parking Officer Parking IOT Sensor System. Over time, the chart displays updateStatus, validatePayment, and other configureZones since they depend on things that happened before. As the project ends, the tasks monitor system logs, configure zones, and operator system admin are all queued up to execute independently after the shared tasks. Ultimately, this image makes it easy to monitor the progress of the project, notice where different tasks overlap, and decide on the most important paths in the 67-day schedule.

Fig. 9.

Scenario 3 Gantt Chart.

The precedence graph of Scenario 3 annotated by CPM is presented in Fig. 10. The nodes show earliest/latest times ((ES, EF, LS, LF)), and shading represents total float (TF = LS = LF-ES = LF-EF); the red edges indicate the critical path (CP). It starts with two feeders; the first is called searchParkingSpot (0.00→19.48, TF = 0), and the second one is known as configureZones (0.00→11.33, TF ~ 8.14)). This has two feeders that join at the reserve spot ((19.48→32.46, TF = 0)) and then flow through the mid-pipeline hub called Driver Parking Officer / Parking IoT Sensor System 32. At the bottom the network becomes a fan to alternative administrative/operational completions, one of which, which is on the CP, is monitorSystemLogs (55.82→71.44, TF = 0). The makespan will be fixed at the time indicated in the schedule, 71.44 time units, by a node that is noncritical; its sibling branches, which are also not critical and allow schedule flexibility, are validatePayment (55.82 to 63.75, TF = 7.68).

Fig. 10.

Scenario 3 precedence graph.

Activities (owner → activity).

1. IoT → Provision parking sensors & gateway (FS → 2).

2. Backend → Ingest telemetry & status service (par with 3).

3. Mobile → Implement availability UI & alerts (join before 4).

4. SecOps → Configure auth/rate-limits (FS → 5).

5. QA → Field tests with synthetic load (FS → 6).

6. Ops → Rollout & analytics dashboard.

Discussion

As presented in Table 5, the result of this analysis suggests that project scheduling methods have been evolving and diversifying lately. The authors of^31,32 illustrate that applying linear programming and CPM in construction projects helps shorten project durations. The authors of³³ suggest that using CPM with crashing methods helps with balancing time and cost, although it only marginally shortens project duration. The authors of³⁴ point out that in some situations, looking at the whole network is more useful than focusing only on the critical path. It is especially important for this perspective when talking about complex jobs because a delay on the critical path may delay other actions as well. Its importance lies in combining Optical Character Recognition (OCR) and CPM to ease the automation of sequence diagram tasks in relation to academic scheduling. It helps simplify the scheduling process and results in a 10% decrease in how long the project takes. Basically, conventional CPM and linear programming are still useful, but using strategies based on OCR and hybrid heuristics in scheduling projects reflects the direction of future progress.

Table 5.

Comparative analysis table: dependency-based scheduling models (2014–2025).

Study reference	Methodology	Key contribution
Salman (2024)31	Linear programming	Optimized critical path identification
Danfulani et al. (2023)32	CPM	Applied CPM to building projects
Abuhasel (2023)33	CPM & Crashing	Time-cost optimization in green city projects
Vazquez et al. (2023)34	Network analysis	Emphasized network structure over critical path
Dyahrini et al. (2022)35	CPM	Scheduling analysis for master plan review
Goncharov (2025)36	Hybrid heuristic	Integrated GA and neighborhood search
Perrucci (2025)37	CPM	Evaluated temporary housing allocation
Blaga et al. (2021)38	CPM	Scheduling for new product launch
Marzouk & Hisham (2014)39	Earned value management	Implemented EVM using bridge information modeling
Proposed Model	Dependency graph & CPM with OCR	Integrated OCR with CPM for scheduling

Conclusion

This paper presents a comprehensive automated framework aimed at seamlessly converting software design documentation into actionable project management schedules. It specifically addresses the significant challenge of transforming UML sequence diagrams—which illustrate system interactions—into executable project timelines, typically represented as Gantt charts and precedence graphs. The primary problem identified is the inefficiency and potential inaccuracies arising from the prevalent manual translation processes, especially within iterative and dynamic software development environments. To tackle this, the research introduces a structured methodological pipeline beginning with Optical Character Recognition (OCR), utilizing EasyOCR, to automate the accurate extraction of task information directly from visual UML sequence diagrams, including task names, participants, and temporal details. These extracted tasks are then systematically organized into a validated Directed Acyclic Graph (DAG) using NetworkX, effectively capturing precise inter-task dependencies. To refine scheduling accuracy, the methodology incorporates gradient descent optimization to iteratively predict and dynamically adjust task durations based on realistic project constraints. Forward pass analysis computes earliest feasible start and end times, while the Critical Path Method (CPM) identifies the tasks critical to project timelines. The paper validates this automated process through detailed experiments involving diverse real-world scenarios—healthcare appointment scheduling, academic course management, and smart parking systems. Results highlight substantial gains in scheduling precision, improved visualization and clarity through generated Gantt charts and precedence graphs, and overall enhancements in planning efficiency. Future directions include extending automation via natural language processing techniques for deeper semantic analysis, integrating real-time scheduling interfaces with collaborative platforms, and evaluating the framework’s scalability in large-scale industry settings. To enhance the representation of time and performance factors in project scheduling, the suggested OCR-based framework can be further developed with the help of UML timing diagrams, timing constraints, and the UML MARTE (Modeling and Analysis of Real-Time and Embedded Systems) profile to be used in future research. By incorporating these UML extensions, the system will capture both control-flow and dependency relations as well as accurate timing semantics, i.e., task durations, deadlines, and synchronization delays. Moreover, improving the OCR pipeline to make timing annotations and MARTE stereotypes readable will allow parsing quantitative time parameters directly out of UML artifacts, knowing that it is automated. This integration will enable the existing model to be more than a structural dependency analysis and a time-conscious and performance-sensitive scheduling model that will help in closing the gap between the semantics of software design and real-time planning of a project. The framework will also address future versions involving hybrid modeling with the integration of a sequence and timing diagram to interpret semantics and better critical path method (CPM) accuracy of the computation.

Author contributions

Conceptualization, A.M.M., A.A. and H.A.; methodology, M.A.M. and A.A.; data curation, A.M.M. and H.A.; formal analysis, A.A. and M.A.M.; investigation, A.A.; resources, A.M.M. and M.A.M.; supervision, A.M.M., H.A. and M.A.M.; writing—original draft, A.A. and H.A.; writing—review and editing, A.M.M. and M.A.M. All authors have read and agreed to the published version of the manuscript.

Funding

This work was funded by the Deanship of Graduate Studies and Scientific Research at Jouf University under grant No (DGSSR-2024-02-02024).

Data availability

Data generated during this study is published within this article.

Declarations

Competing interests

The authors declare no competing interests.