In our previous article, we introduced how Sprinterra assesses the complexity of migrating Acumatica Classic UI screens to the Modern UI. Today, we are excited to share how we are enhancing this estimation framework, what principles guide our roadmap, and how our system continues to learn and adapt based on real-world conversions.
At the core of our approach is a rule-driven evaluation engine designed to measure complexity on a per-screen basis. Each rule focuses on a specific UI element, pattern, or structure. These rules act as modular building blocks – for example, analyzing selectors, buttons, data grids, or custom controls.
Using rules rather than hardcoded logic means our engine can evolve as we learn from more migration projects. Complexity scoring is not static; it improves over time.
Here’s how the system works:
Initially, some page elements will not have specialized rules. In these cases, the engine applies a fallback basic rule – counting tags, lines, or generic indicators – to provide a preliminary estimate. These items are flagged for manual developer review, and if patterns emerge, we add new rules to cover those cases going forward.
This feedback loop ensures that with each project, the engine becomes more accurate, more predictive, and more aligned with real-world effort.
Some UI elements require deeper analysis or special treatment. Our algorithm is evolving to handle these scenarios more intelligently.
Smart Panels behave like micro-screens within the larger page. Our approach is to treat them with the same sophistication as full screens – running them through a full set of rules to estimate their individual complexity.
Because JavaScript can vary wildly, the system cannot fully automate complexity grading.
However, we can:
Over time, commonly recurring script structures may get their own dedicated rules.
CSS rules affect layout and appearance rather than business logic. We calculate weights based on:
In many cases, these files contain standard auto-generated code produced by the Acumatica Framework. Typically, they include only the required boilerplate with no additional custom logic.
If deviations are detected, the engine marks the file for manual review; if not, it receives a zero complexity score.
Future sub-rules will target recurring code-behind customization patterns.
Every include file is evaluated as its own page entity.
The engine:
This insight alone can help reduce clutter in long-standing customizations.
One of the strengths of our system is its plug-and-play rule architecture.
This allows us to iterate quickly based on:
Once the foundational framework is fully established, we will begin implementing property-level evaluation, moving from a purely structural to a more semantic understanding of each screen.
For example:
This “white-box” approach ensures deeper, more accurate evaluation of UI logic – not just UI structure.
We also plan to incorporate a “black-box” perspective by identifying known problematic patterns, such as PXButton tags with conflicting property combinations.
We see significant potential in integrating AI agents into the evaluation workflow.
Each rule could expose a Markdown prompt explaining:
This would enable:
AI assistance would not replace the rule engine – but it could greatly enhance consistency, speed, and insight when handling complex or unusual screens.
What we’re building is not a static tool – it’s a living framework that evolves with each conversion project. The more we migrate, the more accurate our predictions become. The more patterns we identify, the more rules we add. And as Acumatica advances its Modern UI, our system grows alongside it.
Sprinterra’s long-term goal is to provide:
This is how we help partners estimate migrations with greater confidence – and deliver modernization projects faster and smarter.
Get the latest insights on exponential technologies delivered straight to you
It’s a rule-based engine that analyzes each Classic UI screen and scores the effort required to convert it to Acumatica’s Modern UI. The system evaluates UI elements, patterns, and structures, using modular rules that evolve as Sprinterra completes more migration projects.
JavaScript is assessed by analyzing script size, functions, and syntax patterns. CSS complexity is based on rule counts, selectors, and historical effort data. Both can trigger manual review when custom or unusual structures appear.
Smart Panels behave like smaller screens embedded in a page. Because they contain their own controls and logic, Sprinterra evaluates them independently using the full set of rules to ensure accurate scoring.
As the engine learns from real projects, predictions become more reliable. This gives partners clearer estimates, earlier risk visibility, and faster, more confident planning for Modern UI migrations.
Include files are analyzed as separate entities, and their scores are added to the overall total. Code-behind files typically contain autogenerated Acumatica code; if no custom logic is found, they receive a zero score, with exceptions flagged for manual review.
