Dataset on the solution to the guaranteed-service time inventory model across 38 real-world supply chains with normally distributed demand Authors: Luis A Moncayo-Martínez Published: 2026 ABSTRACT AbstractThe placement of safety stock to guarantee a service time has received considerable attention due to its impact on reducing inventory costs across multi-echelon supply chains. This work compiles and analyses the structure of 38 real-world supply chains reported in the literature by characterising their depth, degree, and stage types (distribution, manufacturing, part, retail, and transport). We provide the detailed solutions of the guaranteed-service-time inventory model under normally distributed demand, obtained using branch-and-cut algorithms implemented in commercial optimisers. The resulting dataset includes the optimal safety stock levels, the corresponding CPU time, and full variable values for every instance, with the largest model containing 4,050 variables and 18,890 constraints. All data are provided in CSV format to enable flexible reuse, and the source code for reproducing the plots is openly available. This dataset offers a rigorous benchmark for researchers developing new methods for solving the guaranteed-service-time inventory model, particularly for the four instances where a 25% optimality gap remains.Keywords: Business management, Inventory levels cost, Guaranteed service time, Mathematical programming models Specifications Table SubjectComputer SciencesSpecific subject areaGuaranteed-service time inventory model under normally distributed demand, non-linear programming models, branch-and-cut algorithm.Type of dataTable, Graph, Figure, Raw.Data collectionThe dataset reports the minimum safety stock cost for 38 real-world supply chains, previously published in the literature, under the guaranteed-service time inventory model when demand follows a normal distribution. It also includes the values of all model variables. To compute these values, a directed graph is generated using the Python package NetworkX. A continuous initial solution is obtained with the optimisation modelling language Pyomo and the nonlinear solver IPOpt. This initial solution is then used as input to the Gurobi optimiser, which applies a branch-and-bound algorithm to compute the integer solution. The dataset therefore contains, for each of the 38 supply chains, the continuous and integer solutions together with information on the depth and degree of the corresponding supply chain networks.Data source locationInstitution: Instituto Tecnológico Autónomo de México (ITAM)City: MexicoCountry: MexicoData accessibilityRepository name: GitHubData identification number: 10.5281/zenodo.8209331Direct URL to data: https://github.com/LuisMoncayo/Guaranteed-Servive-Time-Inventory-ModelRelated research articleL. A. Moncayo–Martínez and E. Mastrocinque, “Solving the Guaranteed–Service Time Inventory Model for Real–World Supply Chains by Implementing It in Commercial Optimisers,” Journal of Engineering Research, 13 (3) (2025) 2559–2571, doi: https://doi.org/10.1016/j.jer.2024.05.014. Value of the Data •This dataset reports the minimum safety stock cost required under the guaranteed-service time inventory model for 38 real-world supply chains. As this model is NP-hard, the dataset serves as a benchmark for testing the efficiency and effectiveness of new exact or approximate methods, such as metaheuristics. This dataset reports the minimum safety stock cost required under the guaranteed-service time inventory model for 38 real-world supply chains. As this model is NP-hard, the dataset serves as a benchmark for testing the efficiency and effectiveness of new exact or approximate methods, such as metaheuristics. •Researchers can analyse the solutions and identify structural patterns (e.g., stage depth or connectivity degree) that may guide the development of faster or better-performing algorithms. Researchers can analyse the solutions and identify structural patterns (e.g., stage depth or connectivity degree) that may guide the development of faster or better-performing algorithms. •The dataset includes graph visualisations, degree and depth distributions, and detailed variable outputs, providing an opportunity to study the behaviour of the guaranteed-service time inventory model across a wide variety of supply chain topologies. The dataset includes graph visualisations, degree and depth distributions, and detailed variable outputs, providing an opportunity to study the behaviour of the guaranteed-service time inventory model across a wide variety of supply chain topologies. •Beyond benchmarking, the structure of the instances enables researchers to explore network design questions, conduct robustness analyses, train machine-learning predictors, test decomposition strategies, and develop hybrid optimisation algorithms. Beyond benchmarking, the structure of the instances enables researchers to explore network design questions, conduct robustness analyses, train machine-learning predictors, test decomposition strategies, and develop hybrid optimisation algorithms. •The largest instance contains 4,050 decision variables and 18,890 constraints. Therefore, this dataset establishes a clear benchmark scale-future datasets aiming to improve on this work should include larger or more complex instances. The largest instance contains 4,050 decision variables and 18,890 constraints. Therefore, this dataset establishes a clear benchmark scale-future datasets aiming to improve on this work should include larger or more complex instances. Background This dataset supports the solution approach presented in the related research article [1]. The original algorithm was executed across 38 real-world supply chain instances. Due to the volume of results, not all outputs were included in the research article. This dataset provides complete results for each instance, including variable values, solver logs, and network characteristics such as depth and degree. The associated source code is provided to enable full reproducibility of the results. The guaranteed-service time inventory model captures the balance between inventory cost and customer service by ensuring that strict delivery commitments are met through the strategic placement of safety stock across the network. It directly links customer-facing service performance with internal inventory decisions in a multi-echelon supply chain. In this model, each stage has inbound and outbound service-time variables that determine the safety stock required to buffer demand variability. These variables create a time-feasible plan for the entire supply chain, ensuring that each stage can serve its successors within the promised service time; without such guarantees, delays would propagate upstream, increasing variability and overall cost. As outlined by Humair and Willems [5], the model is defined on acyclic networks to support multi-echelon planning in real-world supply chains and has been widely applied to systems where inventory costs must be minimised while guaranteed service-time constraints are satisfied [3,5]. Although previous studies have proposed solution algorithms for this model [2,3], comparison across methods has been limited by unavailable parameters or missing implementation details. This dataset includes complete model inputs and outputs for 38 supply chains described in Willems [4], where demand is normally distributed. All files required for replication—including solver inputs, results, and visualisations—are provided. Data Description Fig. 1 shows the dataset structure, with the root folder named Data_In_Brief. It contains four subfolders and one CSV file that summarises the solutions for all instances. Structure of the dataset. The instances_data folder includes the structure of 38 real-world supply chains. This file can be downloaded from [4]; it was not created as part of this work. The Excel file contains three sheets per instance: (01_F) a high-level plot; (01_SD) stage attributes such as name, depth, cost, and processing time, along with the average and standard deviation of demand, the maximum service time, and the service level; and (01_LL) the edges list representing the supply chain’s structure. The source_code folder contains three Python scripts used to generate the dataset. The main.py script constructs the supply chain graph using the files from the instances_data folder and solves the guaranteed-service time inventory model (as described in the following section). The graph_analysis.py script calculates the degree and depth of each stage—where the degree refers to the number of incoming and outgoing connections, and the depth indicates the stage’s position in the network. The SC_plot.py script produces structural plots of the supply chains using categorical colour codes for the five stage types: Dist, Manuf, Part, Retail, and Trans. The instances_structure folder contains three subfolders that detail the structure of the 38 real-world supply chains. Each subfolder includes 39 files—one per supply chain and one summary file. For illustration, instance 1 is used as an example, although the description applies to all 38 cases. Fig. 2 illustrates the structure of instance 1 (right) and the corresponding histograms for stage degree and depth (left). A stage’s degree refers to the total number of predecessor and successor stages connected to it. For example, in Fig. 2, stage Retail_0001 has one predecessor (Manuf_0001), giving it a degree of 1. Stage Manuf_0002 has a degree of 5, with three predecessors (Part_0001, Part_0002, Part_0003) and two successors (Retail_0002 and Retail_0003). In instance 1, five stages have a degree of 2, two stages have a degree of 4, and two stages have a degree of 5. Instance 1. Left: combined histograms of stage degree and stage depth (deg_dep01.pdf). Right: categorical plot of the supply chain structure, with colours indicating stage types. A stage’s depth indicates its position within the supply chain. For example, Part_0001, Part_0002 and Part_0003 have a depth of 0 because they have no predecessors; the supply chain starts from these nodes. Stages with depth 1 are those with at least one predecessor of depth 0, such as Manuf_0001 and Manuf_0002. Finally, Retail_0001, Retail_0002 and Retail_0003 each have a predecessor with depth 1 and therefore have a depth of 2. In general, the depth of a stage is defined as one plus the minimum depth among its predecessors. The subfolder degree_depth_histograms contains the degree and depth histograms for all 38 supply chains, as shown on the left of Fig. 2. The subfolder categorical_variables_plots contains the structural plots, such as the one on the right of Fig. 2. It includes a visual representation of each supply chain instance using categorical colour schemes to distinguish between different stages: Part (green), Manuf (yellow), and Retail (blue). This classification helps readers visually understand the supply chain flow, from raw materials (Part) to production (Manuf) and finally to the customer-facing stage (Retail). While these categories do not affect the mathematical formulation of the guaranteed-service time inventory model, they enhance post-solution analysis by making it easier to observe structural characteristics like branching, bottlenecks, and stage connectivity. For instance, identifying where multiple part suppliers feed into a single manufacturing stage or how many retail nodes are downstream becomes straightforward. This aids researchers in interpreting solution patterns, developing heuristics, and exploring the impact of network topology on model performance. Categorical plots are provided in instance01.html format for all 38 instances, allowing interactive inspection of the supply chain structure for each case. The subfolder degree_depth_tables provides a summary for each instance, including the degree, depth, and the number of inbound (In_Edges) and outbound (Out_Edges) connections for every stage. Table 1 summarises the structural properties of each stage in instance 1 as reported in the graph_01.csv file. This compact representation allows readers to quickly identify the hierarchy, branching patterns, and connectivity of the supply chain instance. Table 1File graph_01.csv.Table 1 dummy alt textStageDegreeIn_EdgesOut_EdgesDepthManuf_00015321Retail_00011100Retail_00022200Manuf_00025321Retail_00031100Part_00012022Part_00022022 File graph_01.csv. The file minimum_safety_stock_cost.csv contains the following variables: “instance” (instance name), “Total # Stages”, “Total # Edges”, “demand_stages” (the number of stages where demand is generated and assumed to be normally distributed), and “no_pred_stages” (the number of stages without predecessor stages). The columns “variables” and “constraints” indicate the number of decision variables and constraints in the guaranteed-service time inventory model. The “Init_Sol” field is marked True if Gurobi uses the initial solution generated by IPOpt. “obj_value” refers to the minimum safety stock cost, “Gap%” shows the percentage difference between the best-known objective and the best bound, and “time” records the total CPU time taken to compute the solution. The folder variables_values_per_instance includes two subfolders: init_sol_pyomo, which contains Pyomo’s continuous initial solutions computed using the IPOpt solver, and sol_gurobi, which contains the final integer solutions computed by the Gurobi optimiser. Each file named pyomo_instance_01.csv reports the “time” (in seconds), the safety stock “value”, and a table of variables including “stage” name, inbound service time (β), processing “time” (t), and outbound service time (θ). The corresponding gurobi_instance_01.csv files contain the same variables along with Gurobi’s standard optimisation log and gap statistics. This dataset also offers broad applicability across multiple research areas within operations research and supply chain optimisation. Because each instance includes full structural information, continuous and integer solutions, and solver performance metrics, researchers can use the data to benchmark new exact algorithms, branch-and-cut enhancements, decomposition methods, and heuristic or metaheuristic approaches. The detailed network characteristics make the dataset suitable for studying network design questions—such as how depth, degree, or stage type affect safety stock placement—as well as for developing machine-learning models that predict solution difficulty, optimal stock levels, or promising search strategies. Furthermore, the dataset enables robustness and sensitivity analyses under alternative service-time or demand assumptions. Overall, these instances provide a versatile platform for testing and validating a wide spectrum of optimisation methods and decision-support tools. Experimental Design, Materials and Methods The guaranteed-service time inventory model ensures that customer-facing stages receive their products within a promised service time (Φ)under a bounded demand assumption [5]. The supply chain is represented as a directed acyclic graph G=(V,E), where each node i∈Vdenotes a stage and each arc (i,j)∈Ecaptures the precedence relation between stages. Every stage has a deterministic processing time ti. Inbound service time θispecifies the latest time by which all predecessors must supply stage i, while outbound service time βidefines the promised delivery time to its successors. The objective is to minimise the total safety stock cost S given in Eq. (1), where Iis the interest rate (set to 20% for all instances), zαis the safety factor associated with the service level α(we use the maximum reported value in [4]), and ci and σi denote the cumulative unit cost and cumulative standard deviation at stage i, respectively. Eq. (2) is called the days of inventory and ensures that the outbound service time (θi) cannot be earlier than the inbound service time (βi) plus processing time (ti). Eq. (3) guarantees that the outbound service time of stage i is not greater than the inbound service time of its successor stage j. The guaranteed service time is set in the subset D⊂V of stages where the demand is generated; Eq. (4) ensures that the guaranteed service time is not greater than the outbound service time at those stages. Finally, Eq. (5) states that the inbound and outbound service time value must be at least zero and integers. The guaranteed-service time inventory model assumes that each stage commits to serving its successors within a specified service time (θi), ensuring a time-feasible material flow across the SC. The model assumes deterministic processing times, demand occurring only at terminal stages, and integer-valued inbound and outbound service times. Safety stock is placed at each stage to buffer demand variability during the guaranteed service window, and the replenishment time of every stage is fully determined by its inbound service time θi, processing time ti, and outbound service time βi. A limitation of the model is that this representation idealises real-world operations by assuming no external delays and restricting service times to integer values. Demand at each terminal stage is assumed to be normally distributed, following the standard formulation in the guaranteed-service literature [5]. This assumption enables a closed-form expression for safety stock via the safety factor zα, allowing the objective function in Eq. (1) to be computed analytically. Using normally distributed demand also facilitates comparability across the 38 real-world supply chains and maintains consistency with prior studies. Nonetheless, the normality assumption limits applicability in settings with highly skewed or intermittent demand, where alternative distributions would yield different safety stock requirements. In our experimental design, we solved thirty-eight times the model in Eq. (1) to Eq. (5) once per each real-world supply chain. The resulting data have the minimum safety stock in Eq. (1) and the integer value of the inbound (βi) and outbound (θi) time for every stage. The source_code folder has the main.py file, which is divided into three parts. In the first one it is imported all the data from the file in the folder instances_data; then, using the Python package NetworkX, the SC is created using the edgelist method as follows G = nx.from_pandas_edgelist(edges_data, create_using=nx.DiGraph()). For each stage i, the methods G.predecessors(i) and G.successors(i) select the predecessor and successor stages of i. The maximum value of the service level (αi) of stages who does not have successor stages is the one used to solve the instances. The guaranteed service time (Φ) used to solve the instances is the maximum guaranteed service time. The value of Φ is quoted in the stages with no successors. The continuous initial solution is computed using the Python-based modelling language Pyomo in the second part of the file main.py. The model is created using the method model = pyo.ConcreteModel(name="(GSIM_Pyomo)") and the variables are set as model.βi= pyo.Var(βi bounds=set_bounds_βi, domain=pyo.PositiveReals) for the inbound time and the same for the outbound time. The parameter bounds is based on the maximum time [5] Mi=ti+max∀j(j,i)∈E{Mj}. For the inbound service time (βi) variables the bound is set to Mi−ti. For the outbound service time (θi) is Mi, and the maximum time for stages with no successor, is zero. The model is solved using the library IPOpt library using the method solver = pyo.SolverFactory('ipopt'), status = solver.solve(model, tee=False). To measure the CPU time in which an instance is solved, the function time.time() is used. The initial time begins before the creation of the model pyomo_init_time = time.time(), and it ends after the problem is solved pyomo_fin_time = time.time(). The result of this part is a continuous solution for all the variables in Eq. (5) Finally, the integer solution is found when the initial solution, computed using IPOpt, is input to Gurobi. The model is created using the method m = gp.Model("GSTInvModel") the variables are modelled using out_var = m.addVars(list(G.nodes),lb=0,vtype=GRB.INTEGER, name="y") and are bounded as out_var[i].ub = G.nodes[i]["M"] and in_var[i].ub = G.nodes[i]["M"] -G.nodes[i]["time"]. In this part, it is important to set the termination criterion. The algorithm is finished when Gurobi cannot find a solution to Eq. (1) lower than the current solution after T units of time. The method m.optimize(callback=cb) calls the function that checks if there is a new lower solution. The CPU time is computed in the same way as in the second part. Gurobi uses a branch-and-cut (B&C) algorithm to solve mixed-integer programming models such as the one in Eqs. (1)–(5) [6]. The B&C framework combines branch-and-bound search with cutting-plane generation to efficiently explore the solution space. In this context, Gurobi linearises the nonlinear objective function in Eq. (1), while the generated cuts tighten the linear relaxation, reduce the size of the search tree, and improve convergence for instances with thousands of variables and constraints. The main advantages of the B&C algorithm are its robustness, its ability to exploit problem structure, and its proven performance in large-scale optimisation. Nonetheless, challenges arise for the largest supply chains, where deep search trees and weak relaxations may lead to long CPU times or non-zero optimality gaps, as observed in several of the biggest instances. These cases underscore the computational difficulty of the guaranteed-service time inventory model and motivate future research on specialised cuts, decomposition approaches, or problem-specific heuristics. The graph_analysis.py and the SC_plot.py files use standard methods of the NetworkX package to compute the degree and depth of every stage in every instance (see Fig. 1) and to graph the SC structure using categorical variables (see Fig. 2). The instances_structures folder has the results of the files graph_analysis.py and SC_plot.py. The first file's output is a histogram for the degree and another for the depth per instance; those histograms are shown in Fig. 3 for instances 2 and instance 35, but the reader can check those for all 38 instances in the subfolder degree_depth_histograms. The tables to plot Fig. 3 are in the subfolder called degree_depth_tables; the files are graph_02.csv and graph_35.csv. (Right) deg_dep02.pdf and (Left) deg_dep035.pdf files stored in degree_depth_histograms. The folder categorical_variables_plot has a plot based on the kind of stages. Each colour represents a stage in which an operation is carried out. Green is a supply stage called Part, yellow is a manufacturing stage Manuf, blue is a Retail stage, black is a transport stage called Trans, and a distribution stage Dist is in red. Fig 4 shows the categorical plot for instance 35. Categorial plot for instance 35. File instance35.html in categorical_variables_plot. Fig 5 shows a close-up of the same plot, allowing one to see the labels of each stage and their relationships. Close-up of the file instance35.html. Table 2 shows the values of the variables in the file minimum_safety_stock_cost.csv. Because of the space, the exact values of the variables in Table 2 are different from the columns’ names in the file. Table 2Value of the variables in the file minimum_safety_stock_cost.csv.Table 2 dummy alt textInst.##DemandNo prede.##InitObjective valGapTimeStagesArcsStagesStagesVariab.Constr.SolEq. (1)%1810331621T3,965.4500.021313412630T5,405,926.0100.031718453439T2,760,031.7000.042239944470T27,978.6200.0527318135466T717,020.3600.0628281265668T258.3900.07387861376122F2,324,806.4200.0840482128090F919,009.4100.194952261698127T514,609.4400.010581761345116247T600,355.8700.011681081813136194F4,655,920.3431.012881075123176246T3,705,694.5300.2131084521098216570T3,480,677.6200.014116119665232301F9,113.12111.2151331645621266353T558,119.6391.716145224609290429T1,728,027.60143.2171522119821304461T687,022.5501.5181542242849308406T55,711.45251.4191562631544312434F176,132.692140.720156169274312327F139,497.5700.1211863593476372579F467,057.3321.9222532531231506629T465,927.1651.62327152425198542820T258,533.37119.5243341245422096681621T6,593,550.45688.025409853173948181435T664,786.87438.92646860524019361075F1,789,410.77328.327482941124189641435F416,364.898134.62857722629039811542929T3,578,947.0520143.72961775336512812341735T173,690.071749.730626632220112521478F540,064.407147.0317069085707614122184T13,325,655.6101.132844168522230916882751T307,967.90241.733976100933211919522317T228,643.0425121.8341206406353114824125322F501,033.040127.435138618573661927723279T1,015,864.89799.7361451481267217329026935F357,173.60778.8371479206955927429584107T516,492.2213.638202516225559820405018809F529,193.84020.2 Value of the variables in the file minimum_safety_stock_cost.csv. The file minimum_safety_stock_cost.csv has the following variables: “instance” is the number of the instances; “Total # Stages” includes all the five kinds of stages Part, Manuf, Retail, Trans and Dist; “Total # Arc” is the number of edges among the stages; “demand_stages” is the number of stages where the demand is generated, i.e., stages that do not have successor stages; “no_pred_stages” stages that do not have to wait to be served by other stages; “variables” in the model in Eq. (1) to Eq. (5); “constraints” in the model in Eq. (1) to Eq. (5); “Init_Sol” is true (T) if Gurobi uses the initial solution generated by IPOpt, it is false (F) if the initial solution is used by Gurobi to compute the integer solution; “obj_value” is the minimum value of the safety stock cost computed in Eq. (1); “Gap%” is a measure of the output of Gurobi branch-and-cut algorithm, it is the percentage difference between the incumbent objective and the lower bound for minimization problems; and “time” is the CPU time in minutes to solve the model. The last folder, named variables_values_ per_instance, has the solution of the continuous solution computed by the Pyomo modelling language and the log report of the Gurobi optimiser to compute the integer solution. The subfolder init_sol_pyomo contains the log report for the 38 real-world supply chains. Each instance has one CSV file, e.g., pyomo_instance_02.csv is the generated file for instance 2. The file has the “time to run” and the SC’s number of “vertices” and “edges”, as well as a table with the following variables: “stage” name; “SI” is the continuous value of the inbound service time (β); “time” is the processing time (ti); and “S” is the outbound service time (θ). The subfolder sol_gurobi has 38 CSV files that record Gurobi's standard log report and a table with the integer solution. The log report has information about the number of general constraints, variable types, and simplex iterations, as well as the value of the best objective and the best bound that results in the Gap percentage. Along with the log report, the integer solution is reported in a table with the following variables: “stage” name; “SI” is the integer value of the inbound service time (β); “time” is the processing time (ti); and “S” is the integer outbound service time (θ). Table 3 shows the integer solution for instance 2, reported in the file gurobi_instance_02.csv. Fig. 6 also shows the categorical plot for instance 2 (file instance02.html). Table 3Integer solution for instance 2 in file gurobi_instance_02.csv.Table 3 dummy alt textStage (i)SI (βi)Time (ti)S (θi)Manuf_00010300Trans_00010151Trans_00020151Trans_00030151Trans_00040151Manuf_000211415Retail_000115520Manuf_000311415Retail_000215520Manuf_000411415Retail_000315520Manuf_000511415Retail_000415520 Integer solution for instance 2 in file gurobi_instance_02.csv. Categorial plot for instance 2. File instance02.html in categorical_variables_plot. All the information was computed using a MacBook Pro with an Apple M1 Pro processor, 16 GB RAM memory, 10 cores (8 performance and 2 efficiency), and macOS version 14.5. All the information is generated using the Python language (v. 3.10.8, 64-bit) under conda (v. 23.9.0) and Spyder IDE (v. 5.4.3). The following Python packages are used: networkx (v. 3.1), Pyomo (v. 6.5.0), Ipopt (v. 3.14.11\x3a), gurobipy - Gurobi Optimizer version 9.5.1 build v9.5.1rc2 (mac64[rosetta2]), and pandas (v. 2.1.1). The results in Table 1 show substantial variation in the minimum safety stock cost across the 38 supply chains, ranging from only 258.39 (instance 6) to over 13 million (instance 31). These differences reflect the structural characteristics of each network: instances with long supply chain depth, many demand stages, and high cumulative variability (e.g., instances 27–33) require significantly larger safety stock investments. The number of predecessor-free stages and branching patterns also influence safety stock levels, as networks with multiple upstream sources or deep transformation paths accumulate more variability and therefore generate higher safety stock requirements. CPU time similarly varies with network size and complexity. Small instances with fewer than 20 stages are solved almost instantaneously, while the largest networks—such as instances 21, 24, 27, 29–33—require more than 50 seconds, and in a few extreme cases over 100 seconds. These longer runtimes occur in instances with many stages, wide connectivity, and hundreds of constraints, which lead to deeper branch-and-cut trees and weaker relaxations. Despite this, optimality gaps are zero in most cases; only a few large and highly branched instances exhibit non-zero gaps (up to 25% in instance 18 and 17% in instance 29), highlighting the computational difficulty of the guaranteed-service time model for very large supply chains. Overall, these results illustrate how safety stock requirements and computational effort both scale with supply chain structure. Practitioners can use this information to anticipate inventory investment in complex networks, identify cost-critical stages, and recognise when very large supply chains may require decomposition or heuristic strategies to obtain solutions within practical time limits. In the main Data_In_Brief folder, the file Data_In_Brief.md contains step-by-step instructions for generating the figures and tables from the provided source code. The source_code folder contains three scripts—main.py, graph_analysis.py, and SC_plot.py—which reproduce the full workflow described in this dataset. After downloading the repository, users run main.py to load the instance files, construct the directed supply chain graph using NetworkX, compute a continuous initial solution with Pyomo/IPOpt, and finally solve the integer model with Gurobi. The scripts graph_analysis.py and SC_plot.py then generate the degree/depth histograms and categorical structure plots used throughout the article. Common issues include missing Python packages or incorrect file paths; these are resolved by installing the required dependencies and maintaining the directory structure shown in Fig. 1. To promote reproducibility and benchmarking, the dataset includes all intermediate and final results: continuous Pyomo solutions, Gurobi integer solutions, structural files, and visualisations for all 38 supply chains. Researchers can replicate the entire pipeline by running the provided scripts or modify components to test alternative optimisation approaches. The presence of non-zero optimality gaps in some of the largest instances highlights opportunities for developing new algorithms, specialised cuts, or heuristic warm-starts. By allowing direct comparison of safety stock costs, service times, and CPU performance across instances, this dataset gives researchers a robust platform for validating and improving methods for the guaranteed-service time inventory model. Limitations The model in Eq. (1) to Eq. (5) assumes that the demand is normally distributed; therefore, if the demand follows another probability distribution function, the results cannot be compared. Some files in the subfolder categorial variables plots could take some time to open, especially for the 38th instance. Instance 38, the largest in the dataset, yields a mixed-integer model comprising 4,050 decision variables and 18,890 constraints. The variables represent inbound and outbound service-time decisions for each of the 2025 supply chain stages. Meanwhile, the constraints are derived from network precedence relations and the guaranteed-service requirements outlined in Eqs. (2)–(4). Specifically, every arc enforces feasibility between predecessor and successor stages, while each demand stage adds a constraint to meet promised service times. As the network grows, these constraints accumulate rapidly, creating a massive branch-and-cut model. Implementation proved challenging due to the extensive search tree, weak linear relaxations caused by deep or highly connected graphs, and the significant CPU time required to close the optimality gap. These factors underscore the computational complexity inherent in real-world guaranteed-service planning. Four of the largest supply chains show gaps of up to 25% between the best incumbent and the best bound due to their size, deep multi-echelon structure, and highly connected graphs, which produce weak linear relaxations and slow bound improvement in the branch-and-cut search. These instances generate very large trees that cannot be fully explored within the time limit. Potential ways to reduce these gaps include adding problem-specific cuts, decomposing the network into smaller subproblems, or using heuristic or metaheuristic warm starts to improve the initial solution and accelerate convergence. Future research may explore alternative demand distributions beyond the normal assumption used here, such as Poisson or negative binomial models, which may better capture skewed or intermittent demand patterns. Extending the model to incorporate stochastic processing times or exogenous lead-time variability is another promising direction. From an optimisation perspective, the large search trees and weak relaxations observed in the biggest instances motivate the investigation of specialised cutting planes, decomposition approaches, or metaheuristic and quantum-inspired algorithms that may scale better for complex supply-chain structures. These extensions could further enhance the applicability and computational performance of the guaranteed-service time inventory model. Ethics Statement The authors complied with all ethical guidelines while collecting the data. The secondary data is information from published sources accessible to the general audience. As a result, the authors may use the secondary data without obtaining authorisation. Neither human nor animal experimentation was done by the writers. CRediT Author Statement Luis A. Moncayo–Martínez: Data Curation, Software, Conceptualisation of this study, Methodology, Writing. Acknowledgements This research did not receive any specific grant from funding agencies in the public, commercial, or not-for-profit sectors. Financial support from the Asociación Mexicana de Cultura, A.C. is gratefully acknowledged, as well as the Mexican National Council of Humanities, Sciences and Technologies (CONAHCYT). Declaration of Competing Interests The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper. Data Availability GitHubGuaranteed Service Time Inventory Model (Original data). GitHubGuaranteed Service Time Inventory Model (Original data). References Associated Data Data Availability Statement GitHubGuaranteed Service Time Inventory Model (Original data). GitHubGuaranteed Service Time Inventory Model (Original data).