Teams should start with the standard floorplans and only move to custom UI code when a requirement cannot be expressed cleanly through annotations or extension points. The decision should weigh process fit, upgrade resilience, and long-term maintenance. If the customisation changes navigation, draft handling, or message behaviour, the case for staying within Fiori elements is usually stronger.
Why the standard option should be the default
Fiori elements is the safer starting point because it keeps the app aligned with SAP’s intended floorplans, annotation model, and extension mechanisms. That usually gives teams a cleaner upgrade path, less duplicated logic, and more predictable behaviour across list, object, and analytical pages. The central question is not whether custom UI is possible, but whether the requirement genuinely needs code that the standard model cannot represent.
When teams begin with custom UI too early, they often trade a small design gain for a permanent maintenance burden. Every bespoke interaction has to be retested against future platform changes, and the cost grows when the app depends on navigation patterns, draft handling, or message flows that the framework already manages well. For many business apps, the standard approach is not a compromise, it is the more resilient architecture.
Standard floorplans also make the solution easier for other developers to understand and support. That matters because UI decisions are not just about the first release, they shape how safely the application can be extended, fixed, and governed over time. If the requirement can be met with annotations, controllers, or extension points, teams usually preserve more of the framework’s value by staying within Fiori elements.
When custom UI code is justified
Custom UI code becomes appropriate when the business requirement cannot be expressed cleanly in the standard model without distorting the user experience or creating brittle workarounds. Typical triggers are highly specific interaction patterns, unusual screen composition, or logic that would be awkward to force into the standard page templates. The threshold should be functional necessity, not preference for a more distinctive look and feel.
The strongest justification is usually not visual design alone, but a genuine mismatch between the process and the floorplan. If the application needs behaviour that changes the meaning of navigation, draft state, or server-side messaging, the team should treat that as a serious signal. Those are core mechanics, not cosmetic details, and bypassing them can create confusing state transitions or inconsistent user feedback.
Custom code also makes sense when the team can describe exactly what is being lost by staying standard. If the answer is merely that the page would be less polished or would take more effort to adapt, that is usually not enough. If the answer is that the standard framework cannot represent the process correctly, cannot preserve the necessary interaction model, or cannot support the required transaction flow, then customisation is easier to defend.
How to make the trade-off explicitly
The decision should be made as a product and engineering trade-off, not as a stylistic preference. Teams should compare process fit, upgrade resilience, and long-term maintenance in the same review, because a solution that feels fast to build can become expensive to sustain. A good rule is to exhaust annotations and extension points first, then move to custom code only when the remaining gap is real and material.
It helps to separate requirements into three buckets: what can be modelled, what can be extended, and what must be coded. That structure prevents teams from overusing custom UI for requirements that could have been expressed declaratively. It also forces an explicit discussion about whether the custom behaviour is a one-off exception or a pattern that will recur across multiple apps.
Teams should also consider the support model. Standard Fiori elements generally make regression testing, onboarding, and future refactoring simpler, while custom UI increases the amount of application-specific knowledge the team must retain. If the implementation is likely to evolve over several releases, the long-term cost of ownership should carry more weight than the short-term speed of delivery.
Practitioner Guidance
What to prioritise: Start by testing whether the requirement can be satisfied through annotations and extension points without altering core framework behaviour. If it can, that is usually the preferred route because it preserves maintainability and upgrade resilience.
Decision rule: If the customisation would materially change navigation, draft handling, or message behaviour, treat that as a strong warning that the standard floorplan is still the better option. Only move to custom UI when the business process truly cannot be represented otherwise.
Common mistake: Teams often justify custom UI because it seems easier to shape the screen than to reshape the requirement. In practice, that usually shifts complexity from design time into testing, upgrades, and support.
Practitioner takeaway: Use standard Fiori elements unless the requirement forces you outside the framework’s natural model, because the real cost of custom UI is usually paid later in resilience, supportability, and upgrade effort.
Related resources from NHI Mgmt Group
- What breaks when teams overextend Fiori elements with custom code?
- How should teams decide between EV code signing and standard code signing for software releases?
- How can teams decide whether a custom alert belongs in standard monitoring or a bespoke script?
- How should teams decide between a standard and a custom identity design?
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 2, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org