Historically, enterprise software solutions have coupled components of the application together tightly, resulting in systems that can be difficult to maintain and enhance over the long term. For example, the content delivery front-end of a website invoked APIs (Application Programming Interfaces) or SDKs (Software Development Kits) in the content management system (CMS) and the commerce platform. To retrieve and present content from those systems, front-end developers must have detailed knowledge of and expertise in all source platforms. This results in tight coupling between the front-end code and the back-end systems, which can be brittle and difficult to maintain. Changes such as upgrades to any of the source systems have ripple effects that require changes to other systems and custom code.
Composable software solutions allow for decoupling on the objective of decoupling software solutions. Composable software solutions allow organizations to stitch together applications from multiple vendors that they consider most optimal for meeting their individual needs. Rather than relying on software suites of pre-integrated components from a single vendor that may not provide the best fit for every implementation, system architects implement solutions using discrete components from multiple vendors, where each component serves a single business function.
In the context of composable architecture, agnostic software refers to applications that are indifferent to, unaware of, and unaffected by the implementation specifics of other components used in the solution. Agnostic software does not directly invoke APIs or use SDKs from other components or process their native data structures such as JSON. Instead, agnostic software employs abstraction techniques that insulate components from each other. This approach allows changes and even wholesale replacement of system components with minimal impact on the overall solution, including any custom code. Agnostic software supports enterprise agility by allowing customers to replace pieces of the solution without impacting the existing implementation, and to add additional elements as they emerge or as the need arises.
Agnostic software helps organizations minimize costs and reduce the risks by enforcing the loosest possible coupling between applications. Loose coupling lets customers integrate, replace, and add software components from multiple vendors while minimizing the need for developers experienced with specific technologies.
When designing websites driven by headless content management systems, architects can implement various degrees of coupling. The less that front-end relies on APIs and JSON formats from the CMS vendor, the looser the coupling between that custom code and the back-end platform. In general, the more CMS features on which the front-end depends, the tighter the coupling. The more CMS APIs that a solution uses the greater the knowledge of the CMS that developers must have to maintain the solution, and the harder it will be to replace that CMS with another. Adding additional components such as commerce and search exacerbates the challenge further, eventually reaching a point where the solution no longer feels composable, and the relative advantages of monolithic platforms begin to appear preferable again.
Using features from the CMS vendor to control page presentation is an example of tight coupling between the front-end code and the back-end platform. The more that the CMS controls page visuals, the more that code depends on the implementation of the CMS. Perfection is an agnostic software application that, among other things, lets CMS users control page presentation without relying on developers or tightly coupling front-end code to the back-end solution. Rather than using CMS APIs and JSON formats to control page presentation, Perfection provides a presentation abstraction layer between the front-end code and the CMS that lets the marketing team control layout and design without depending on developers or knowledge of CMS. By simply referencing Perfection's client-side JavaScript and CSS, adding data attributes (data-pf) and pushing layout & component definitions through our CLI; developers enable CMS users to design sections and components, and to style those elements within brand constraints. These styles are pulled through our runtime API when the page is built or served - or you use the webhooks to store the styles in your own platform or a Digital Experience Orchestration layer.
As its software has no knowledge of the connected systems, Perfection's approach works for data sources other than CMS, including commerce engines and Digital Experience Orchestration (DXO) products. Because the front-end code never calls any of these vendor's APIs directly, or processes data in any of their native formats, the front-end contains no coding specific to these platforms. Additionally, Perfection enhances DXOs with facilities that allow CMS users to control page presentation, which is not a core capability of a DXO.
With Perfection, developers use the same techniques to enable features regardless of which systems you connect, and with no knowledge of the APIs used by those systems.