Retrofitting custom C-codeCustom programs written in the C programming language, often used for JD Edwards Business Functions. is frequently mismanaged as a simple 'compare and merge' exercise, but that assumption is what leads to catastrophic memory violationsErrors where a program tries to access memory it shouldn't, leading to crashes or instability. in production. While the vast majority of your legacy custom Business FunctionsReusable C or NER programs in JD Edwards that encapsulate specific business logic. will compile cleanly in EnterpriseOne 9.2A specific version of Oracle JD Edwards EnterpriseOne, an ERP software suite., a critical minority represent a high-risk surface area where misaligned Data Structures (DSTR)Defined layouts for data in JD Edwards, used to pass information between functions. and pointer handling issuesProblems in C code related to how memory addresses are managed, often leading to errors or crashes. reside. Implementing a rigorous JDE BSFN code review checklistA systematic list of items to check when reviewing JD Edwards Business Function code for quality and compliance. for upgrade readinessThe state of an application or system being prepared and compatible for an upgrade to a newer version. as a pre-retrofit auditAn inspection or review conducted before making modifications (retrofitting) to existing code. ensures these structural flaws are identified before they are baked into the new path codeA JD Edwards concept referring to a specific set of objects (e.g., DV920, PY920, PD920) for development, test, or production..

For an enterprise environment with 200–500 truly impacted objects, this disciplined approach typically saves two to four weeks of high-pressure debugging during the UAT phaseUser Acceptance Testing phase, where end-users test the system to ensure it meets business requirements.. The goal is to move beyond simple syntax validationChecking code for correct grammar and structure according to the programming language rules. and verify that custom logic respects the memory management and 64-bit requirementsTechnical specifications for software to run on systems using 64-bit processors and memory addressing. of the latest Tools ReleaseA specific version of the JD Edwards EnterpriseOne development tools and runtime components.. This checklist provides technical leads with a concrete framework to validate code integrity before customisationsModifications or enhancements made to standard software to meet specific business needs. reach the 9.2 Central ObjectsA repository in JD Edwards that stores definitions for applications, reports, and business functions., preventing unstable logic from polluting the upgraded environment.

Validating Data Structure Alignment and Pointer Integrity

A mismatched data structure (DSTR)Defined layouts for data in JD Edwards, used to pass information between functions. between the C header fileA file in C programming (.h extension) that declares functions, data structures, and variables used in other C files. and the central objects repositoryA repository in JD Edwards that stores definitions for applications, reports, and business functions. is the most common cause of "Zombie" kernelsA JD Edwards kernel process that is no longer responsive but still consuming system resources. and memory corruptionErrors where the contents of memory are unintentionally altered, leading to unpredictable program behavior. in a 9.2 environment. During an upgrade, developers often regenerate the DSTR but fail to update the .h file manually or vice versa, leading to offset shifts that cause the runtime to write to the wrong memory address. In a recent 9.1 to 9.2.7 migration, we identified between 10 and 20 custom BSFNs where the typedefA C keyword used to create an alias for a data type, often used for data structures. in the source code lacked three parameters added to the standard DSTR by an Oracle ESUOracle Electronic Software Update, a patch or fix released by Oracle for JD Edwards.. This misalignment does not always trigger a compile errorAn error detected by the compiler during the process of converting source code into executable code., but it will reliably crash a CallObject KernelA JD Edwards server process responsible for executing Business Functions. the moment a user hits the OK button on a high-volume transaction screenAn application screen in JD Edwards used for processing a large number of business transactions..

Eliminating Hard Coded Values and Environment Logic

Scouring custom BSFNsAbbreviation for Business Functions, reusable C or NER programs in JD Edwards. for strcpy(szEnvName, "PD910")A C function call to copy a string, here hardcoding an environment name, which can cause issues in different environments. is a non-negotiable step in any 9.1 to 9.2 migrationThe process of upgrading a JD Edwards system from version 9.1 to 9.2.. Logic branches frequently fail silently because a developer hard-coded a pathcode checkLogic in code that verifies or depends on a specific JD Edwards path code (e.g., PD920, PY920). years ago to handle a specific data conversion or interface trigger. In a 9.2 environment, these strings are dead weight; the code will fail to find the environment or, worse, attempt to point back to a decommissioned 9.1 data sourceA database or system from the older 9.1 environment that is no longer in use.. You must replace these literals with a call to jdeGetEnvironmentNameA JD Edwards API function to retrieve the current environment name dynamically, avoiding hardcoding. or pull the value from the lpBhvrCom structureA pointer to a common behavior structure in JD Edwards, containing context information about the current execution. to ensure the logic remains environment-agnosticCode designed to work independently of the specific environment it runs in..

File handling logic often harbors hard-coded directory strings like C:\JDE_Interfaces or /u01/app/jde/input, which are guaranteed to fail when moving to OCIOracle Cloud Infrastructure, Oracle's suite of cloud computing services. or a modern Linux-based enterprise serverA server running the Linux operating system, typically in a large organization.. In one recent 400-object retrofit, we found between 10 and 15 custom BSFNs where file paths were concatenated directly in the C code rather than being retrieved from Processing OptionsUser-definable parameters for JD Edwards applications and reports, allowing flexible behavior without code changes. or the F986110A JD Edwards system table that stores information about batch applications and reports, including their processing options.. Moving these to a System LocationA method to retrieve system-specific paths or values from a central configuration. lookup or a dedicated UDC tableUser Defined Code table in JD Edwards, used to store configurable lists of values. allows the CNC teamConfigurable Network Computing team, responsible for managing the JD Edwards technical architecture and servers. to change paths without requiring a full build and deploy cycleThe process of compiling, packaging, and distributing software changes to target environments.. This change eliminates the "file not found" errors that typically plague the first 48 to 72 hours of a 9.2 cutoverThe final transition or switch to the new JD Edwards 9.2 system..

Legacy logic frequently relies on specific Terminal IDAn identifier for a user's terminal or workstation. or User ID naming conventionsRules or patterns for how user identifiers are structured. that were standard in the 9.1 Citrix or fat client eraRefers to the time when JD Edwards users primarily accessed the system via Citrix or thick client installations.. Many custom BSFNs still check for "JDE" prefixes or specific character lengths to distinguish between batch and interactive sessions. With the shift to AIS-based orchestrationsJD Edwards Orchestrations that use the Application Interface Services (AIS) server to interact with EnterpriseOne. and the retirement of traditional fat clientsDesktop applications that run directly on a user's computer, requiring local installation., these assumptions break. You need to audit any logic that parses szMachineKeyA variable in JD Edwards typically holding the machine identifier. or szUserIdA variable in JD Edwards typically holding the user identifier. to ensure it doesn't inadvertently exclude web-based sessionsUser interactions with JD Edwards through a web browser. or Orchestrator service accountsUser accounts used by JD Edwards Orchestrator to perform automated tasks. that use different naming patterns.

Hard-coding '00000' for CompanyDirectly embedding a fixed value for the Company field in code, rather than making it configurable. or specific Business UnitsOrganizational units within JD Edwards, used for financial reporting and operational tracking. like ' 1' inside a BSFN creates a maintenance nightmare during a multi-currencyA system configured to handle transactions and reporting in multiple currencies. or multi-company expansionExtending a system to support multiple legal entities or companies.. If a custom C-functionA function written in the C programming language. uses a literal stringA fixed sequence of characters directly written into the code. for a default MCUDefault Business Unit (MCU is the internal field name for Business Unit)., it bypasses the flexibility of the JDE data modelThe structure and relationships of data within the JD Edwards system.. We recommend migrating these constants to a UDC table or fetching them from a custom constants tableA custom database table used to store configurable constant values.. This shift ensures that when the business adds a new entity or re-orgs their chart of accounts, the logic doesn't require a developer to re-compile C codeThe process of recompiling C source code into executable form after changes. in the middle of a production dayA normal business day when the live system is in use..

The Standard Copy Debt Audit

In our experience with 9.2 migrations over the last five years, the most persistent risk is the "55" version of XT4311Z1A standard JD Edwards Business Function, often related to purchasing or inventory. or B4200310A standard JD Edwards Business Function, often related to sales order processing. that was cloned in the 8.12 or 9.0 eraRefers to older versions of JD Edwards EnterpriseOne. and never updated. These custom copies represent the highest risk of silent failureA program error that occurs without any explicit error messages or visible signs of malfunction. because they bypass every fix Oracle has releasedOracle, the company that owns JD Edwards, has released. in the intervening decade. When you clone a master business functionThe original, standard version of a Business Function provided by Oracle. to inject a single line of custom logic—perhaps to override a GL dateGeneral Ledger date, used for financial accounting entries. or force a specific hold codeA code used in JD Edwards to put a transaction on hold.—you are effectively freezing that logic in time. In the 9.2 baselineThe standard, unmodified version of JD Edwards 9.2., XT4311Z1 has undergone significant refactoringMajor restructuring of code to improve its design, maintainability, or performance without changing its external behavior. to support new tax regulations and enhanced receipt routingImproved functionality for managing the flow and processing of received goods., yet your custom copy remains blind to these updates.

Your review must begin with a line-by-line diffA comparison of two files, showing the exact differences between each line of code. between the current Oracle masterThe original, standard version of a component provided by Oracle. and your custom cloneA copy of a standard JD Edwards object that has been modified for specific business needs.. It is not enough to check if the code compiles; you must identify if the original BSFN has received critical ESUsImportant Oracle Electronic Software Updates (patches) that address significant issues. that address data integrityThe accuracy, consistency, and reliability of data. or performanceHow efficiently a system or program executes tasks.. For instance, if Oracle changed the way the F4311A JD Edwards table, likely related to purchase order detail. edit line handles multi-currency conversionsThe process of converting financial amounts between different currencies. in a recent Tools Release, your custom copy will likely produce orphaned recordsDatabase records that no longer have a valid link to a parent record, often due to data integrity issues. or rounding discrepanciesSmall differences in calculated values due to rounding, especially in financial calculations.. This audit should also flag 'hidden' dependencies where your custom copy calls internal sub-functionsPrivate functions called by a main function, not intended for external use.. Oracle frequently renames or deprecatesMarks a feature or function as outdated and advises against its use, often with a replacement. these internal members during minor updates, leading to "Business Function Not Found" errorsAn error indicating that the system cannot locate a specified Business Function. that only surface at runtimeThe period during which a program is executing.. We have seen instances where a custom copy of B4200310 failed because it relied on a specific memory pointer structureThe way memory addresses are organized and referenced within a program. that Oracle refactored to support 64-bit processingThe use of 64-bit processors and memory addressing, allowing for larger memory access and improved performance..

The goal of a 9.2 migration is to move toward a zero-mod coreA strategy to keep the core JD Edwards system as close to standard Oracle code as possible, minimizing modifications. by replacing these clones with Wrapper BSFNsA Business Function that encapsulates a call to another standard Business Function, adding custom logic before or after.. Instead of maintaining 2,000 lines of cloned C code, write a slim wrapper that calls the standard XT4311Z1 and then executes your specific logic either before or after the standard call. If the requirement is purely data-driven, an Orchestration can often replace the custom logic entirely by utilizing AIS to intercept the input before it ever hits the BSFN layer. This shift reduces your technical debtThe implied cost of additional rework caused by choosing an easy but limited solution now instead of a better approach. from a massive code-maintenance burden to a manageable set of extension pointsSpecific locations in a software system designed for adding custom functionality without modifying the core code. that survive future Application UpdatesNew versions or patches for JD Edwards applications released by Oracle. without manual interventionHuman involvement required to perform a task or resolve an issue..

Table I/O Loops and Fetch Performance

A custom BSFN performing a non-indexed fetchRetrieving data from a database table without using an index, which can be slow for large tables. on the F0911The JD Edwards General Ledger Detail table, often very large. is the fastest way to derail a 9.2 go-liveThe point in time when a new system or application is put into active use.. In environments with 50 million rows or more, a poorly constructed JDB_FetchA JD Edwards API function used to retrieve a single record from a database table. loop that lacks a specific index or fails to use JDB_SetSelectionA JD Edwards API function used to define the selection criteria for database queries. correctly triggers a full table scanA database operation where every row in a table is read to find matching records, which is inefficient for large tables.. We have observed short-running UBEsUniversal Batch Engine, a JD Edwards component for running batch processes and reports. ballooning to several hours post-upgrade because the migration to OCI or AzureOracle Cloud Infrastructure or Microsoft Azure, both cloud computing platforms. exposed latent latenciesDelays or slowdowns that were present but not noticeable in one environment, becoming apparent in another. that were previously masked by over-provisioned on-prem hardwareOn-premise servers with more resources (CPU, memory, storage) than strictly necessary, masking performance issues..

C-code that defaults to a "Select *A SQL query pattern that retrieves all columns from a table, often inefficient." pattern by passing a NULL pointerA pointer that does not point to any valid memory address. to the column list in JDB_OpenTableA JD Edwards API function used to open a database table for reading or writing. creates unnecessary overheadExtra processing or resources consumed that are not essential for the task.. Fetching all 120+ columns of the F4211The JD Edwards Sales Order Detail table. when only the price and quantity are needed increases the payload sizeThe amount of data being transmitted in a network request or response. and network round-trip timeThe time it takes for a signal to travel from a sender to a receiver and back.. In cloud-hosted architecturesSoftware systems deployed and running on cloud computing platforms., where latency between the logic tier and the database tierThe delay in communication between the application server (logic) and the database server. is more variable, restricting the fetch to a defined data structure of five or six columns can reduce BSFN execution timeThe time it takes for a Business Function to complete its processing. by 30% to 40%.

The 9.2 release introduces extended Audit FieldsSystem-maintained fields in JD Edwards tables that track changes, such as who created/modified a record and when. that must be handled correctly by custom JDEBASE API callsApplication Programming Interface calls to the core JD Edwards database access layer.. If a custom BSFN performs a direct JDB_UpdateTableA JD Edwards API function used to update records in a database table. without accounting for these new fields or the associated table triggersDatabase objects that automatically execute a specified set of SQL statements when a change occurs on a table., the audit trailA record of events that allows tracking of changes and actions within a system. becomes unreliable. Verification is required to ensure that custom table I/O logic respects the updated table specificationsThe defined structure and properties of a database table., particularly in modules like General LedgerThe main accounting record of a business. and InventoryThe stock of goods a business holds for sale. where data integrityThe accuracy, consistency, and reliability of data. is non-negotiable for financial reportingThe process of generating financial statements and reports..

High-volume batch processesAutomated tasks that process a large number of records in a single run. are frequently compromised by missing JDB_CloseTableA JD Edwards API function used to close a previously opened database table. calls within nested loopsProgramming constructs where one loop is contained within another., leading to cursor exhaustionA database error that occurs when a program opens too many database cursors without closing them.. Modern cloud database platformsDatabase services offered by cloud providers (e.g., AWS RDS, Azure SQL Database, Oracle Autonomous Database). often enforce stricter resource limitsRestrictions on the amount of CPU, memory, or other resources a process can use. than legacy on-prem instancesOlder database installations running on servers located within the organization's own data center., meaning a BSFN that functioned for years may suddenly fail with a "Maximum Open Cursors Exceeded" errorA specific database error message indicating too many open cursors.. Every handle opened must be explicitly closedResources (like database handles) that are intentionally released by code. within the same scopeThe region of a program where a variable or resource is accessible. to ensure the system remains stable during massive data conversionThe process of transforming and moving a large amount of data from one format or system to another. or month-end processing runsAutomated tasks performed at the end of each month for financial closing and reporting..

Memory Management and Cache Cleanup

A custom BSFN that fails to pair jdeCacheInitA JD Edwards API function to initialize a cache for storing data in memory. with jdeCacheTerminateA JD Edwards API function to release resources associated with a cache. is a silent killer of CallObject Kernel stabilityThe reliability and consistent operation of the JD Edwards CallObject Kernel processes.. In high-volume environments processing 10,000+ records via Orchestrator, a single leaked cache handleA cache resource that was initialized but not properly terminated, leading to memory consumption. per execution can exhaust kernel memoryWhen a server process runs out of available memory. within hours, leading to the dreaded "Zombie Process" stateA process that has completed execution but still has an entry in the process table, often due to a parent process not collecting its exit status.. You must audit every logical exit pointAny point in a program where control flow leaves a function or block of code. in your C code, especially error-handling branchesSections of code designed to manage and respond to errors. that return ER_ERRORA common return code in JD Edwards indicating an error.. If the code exits early due to a failed fetch or invalid parameter, the cache must be terminated and the handle clearedA reference or identifier to a resource that is properly released., or that memory remains reserved until the kernel eventually restarts.

The transition to a 64-bit JDE runtimeThe JD Edwards execution environment configured to run on 64-bit architecture. changes how memory fragmentationA condition where memory is divided into many small, non-contiguous blocks, making it difficult to allocate larger blocks. impacts the system, making the 1:1 ratio between jdeAllocA JD Edwards API function for allocating memory. and jdeFreeA JD Edwards API function for freeing previously allocated memory. more critical than ever. We frequently find custom code where a pointer is allocatedMemory is reserved and a pointer is set to its address. inside a loop but only freed once at the end of the function, or where a pointer is reassignedA pointer is made to point to a different memory location without freeing the original. before the original block is released. Ensure that every byte allocated for a structure or string is explicitly freedMemory that is intentionally released back to the system. before the function returns control to the engineThe core execution environment of JD Edwards.. This is particularly vital for BSFNs that manipulate large strings or JDEBase data setsData structures or collections managed by the JD Edwards base API layer. in memory, where a multi-megabyte leakA memory leak where a program continuously loses several megabytes of memory. per call can quickly aggregate across 50 concurrent users50 users accessing the system simultaneously..

The lpBhvrCom pointerA pointer to a common behavior structure in JD Edwards, containing context information about the current execution. remains a frequent source of null pointer exceptionsErrors that occur when a program tries to use a pointer that doesn't point to a valid memory location. during 9.2 upgrades. Custom functions often attempt to access members of this structure to determine the calling formThe interactive application screen from which a Business Function was invoked. or application contextInformation about the current application, user, and environment.. However, when these functions are triggered via AIS, Orchestrator, or a UBE, the interactive event flowThe sequence of events and user interactions in a graphical user interface. is bypassed, and those pointers may be null. You must refactorTo restructure existing computer code without changing its external behavior. any logic that depends on lpBhvrCom to use the BSFN data structureThe input/output parameters defined for a Business Function. instead, ensuring the code remains execution-agnosticCode that can run correctly regardless of how it was invoked (e.g., from a form, batch, or API). regardless of whether it was called from a Power FormA type of interactive application in JD Edwards, known for its rich user interface capabilities. or a REST APIRepresentational State Transfer Application Programming Interface, a standard for web service communication..

Legacy BSFNsOlder Business Functions, often written for previous versions of JD Edwards. that store session-level dataData that is specific to a single user's session and should not be shared across sessions. in static global variablesVariables declared globally and retaining their value throughout the program's execution, shared across all threads. within a .c file are fundamentally incompatible with the multi-threaded HTML server environmentA web server setup where multiple user requests are handled concurrently by different threads within the same process.. Because a single kernel processA single instance of a JD Edwards server process. can serve multiple user sessions, data from User A can bleed into User B’s transactionData from one user's session unintentionally affecting another user's session. if state is not properly isolatedWhen data or variables are not kept separate for individual user sessions.. Replace these static variables with jdeCacheA JD Edwards API for managing in-memory caches, often used to store session-specific data. to ensure that data is keyed to a specific User, Job Number, or Session IDUnique identifiers used to distinguish different user activities or processes.. This architectural shiftA fundamental change in the design and structure of a software system. is mandatory for any 9.1 to 9.2 migration where the client intends to expand their web server footprintThe resources (memory, CPU) consumed by the web server components. or utilize parallel processingExecuting multiple tasks or parts of a task simultaneously. in the UBE queuesQueues in JD Edwards where Universal Batch Engine jobs are submitted and processed..

Deprecated API and Syntax Modernization

Standard strcpy callsA C function call to copy a string, which can be unsafe if the destination buffer is too small. are a liability in the 9.2 ecosystem, particularly as clients migrate to 64-bit processingThe use of 64-bit processors and memory addressing, allowing for larger memory access and improved performance.. We have seen 15-year-old custom BSFNs crash kernelsCause the JD Edwards server processes to stop unexpectedly. because a 30-character string was copied into a 26-character buffer without bounds checkingCopying data into a memory area without verifying if the data fits, leading to overflow.. Replacing these with jdeStrncpyA safer JD Edwards API function for copying strings, allowing specification of buffer size to prevent overflows. is a non-negotiable step. You must pass the destination buffer size minus one to ensure null terminationAdding a null character (\0) at the end of a string to mark its end. and prevent the memory corruptionErrors where the contents of memory are unintentionally altered, leading to unpredictable program behavior. that frequently plagues modern tools releasesRecent versions of the JD Edwards Tools Release. on 64-bit logic serversServer machines running JD Edwards logic processes on a 64-bit operating system..

Audit every NERNamed Event Rule, a type of JD Edwards Business Function that uses a graphical interface for development. for the 'Execute External Program' system functionA JD Edwards function that allows calling external executables or scripts. to identify dependencies on obsolete 32-bit executablesOlder executable programs compiled for 32-bit systems, incompatible with 64-bit environments.. If your logic calls a compiled C++ utilityAn external program written and compiled in C++. or a batch fileA script file containing a series of commands for a command-line interpreter. relying on 32-bit DLLsDynamic Link Libraries compiled for 32-bit systems., the process will fail with a COB0000012 errorA specific JD Edwards error code, often related to issues with external program execution. upon upgrading to Tools Release 9.2.6 or higherSpecific versions of the JD Edwards Tools Release.. A recent audit of 400 custom NERs revealed that roughly 10-15% contained paths to bin32 directoriesDirectories containing 32-bit executable files. that would have halted an OCI migrationMoving JD Edwards systems to Oracle Cloud Infrastructure.. Replace these legacy calls with Orchestrator or native BSFNsBusiness Functions developed directly in C or NER within JD Edwards..

Currency precisionThe number of decimal places used for currency values. requires strict adherence to MathNumeric APIsA set of JD Edwards API functions designed for precise mathematical operations on numeric values, especially currency. rather than converting values to C doublesA standard C data type for floating-point numbers, which can have precision issues in financial calculations. for calculation. Using native C-type castingConverting a value from one C data type to another. in multi-currency environmentsSystems configured to handle transactions in multiple currencies. with 4 or 5 decimal places often leads to rounding errorsInaccuracies introduced during numerical calculations due to rounding. of 0.0001 per line itemA small rounding error occurring for each individual transaction line.. These discrepancies aggregateSmall errors accumulating to become larger, significant differences. into significant variances in the F0911 tableThe JD Edwards General Ledger Detail table, often very large. during month-end reconciliationThe process of verifying and matching financial records at the end of a month.. Ensure all custom BSFNs utilize MathCopyA JD Edwards MathNumeric API function for copying numeric values precisely., MathAddA JD Edwards MathNumeric API function for adding numeric values precisely., and MathDivideA JD Edwards MathNumeric API function for dividing numeric values precisely. to maintain the integrity of the JDE application layerEnsuring the accuracy and consistency of data and logic within the JD Edwards application..

Direct file system accessAccessing files on the operating system directly using standard programming language functions. via fopenA standard C function for opening files. or fprintfA standard C function for writing formatted output to files. fails when moving JDE workloads to the cloudMoving JD Edwards application and database processing to cloud platforms.. Switch to JDE File Handling APIsJD Edwards API functions specifically designed for file operations. like jdeFopenA JD Edwards API function for opening files. and jdeFwriteA JD Edwards API function for writing to files. which handle cross-platform line endingsDifferences in how new lines are represented in text files across different operating systems. and security permissionsAccess rights that control who can read, write, or execute files. automatically. Custom code often fails during a migration to Linux-based OCI nodesServers running Linux on Oracle Cloud Infrastructure. because it attempts to write to hardcoded Windows pathsFile paths specifically formatted for Windows operating systems (e.g., C:\temp). like C:\temp. Standardizing on JDE APIs ensures your code remains portableSoftware that can be easily moved and run on different operating systems or environments. across Windows, Linux, and iSeries architecturesDifferent operating system and hardware platforms supported by JD Edwards..

A BSFN code review provides little value without a concrete remediation planA detailed strategy for fixing identified problems.. If you're tackling a 9.1 to 9.2 migration, understanding retrofitting patternsCommon or best-practice approaches for modifying existing code to fit new requirements or environments. is critical for managing your custom object estateThe collection of all custom-developed objects (e.g., Business Functions, applications, reports) in a JD Edwards system. effectively. We have detailed common performance tuning strategiesMethods used to improve the speed and efficiency of a system or application. and efficient retrofitting approachesEffective and streamlined ways to modify existing code. in other technical articles on this site. You can also explore our project portfolioA collection of past projects or case studies. to see how these code review checklists and remediation strategies were applied in real-world 9.2 migrations for global manufacturing clientsManufacturing companies with operations in multiple countries., often reducing upgrade timelinesThe estimated duration for completing an upgrade project. by 20–30% compared to typical estimates.