Following recent Google Cloud/DORA reports linking high deployment frequency directly to platform engineering culture, the enterprise sector has finally recognized that point automation via disparate scripts is a dead end. In an era where business agility is critical, software delivery speed determines the viability of large organizations. However, enterprise systems often fall into a trap: developers spend up to 50% of their time writing "infrastructure glue"—manually synchronizing database schemas, API endpoints, and UI components—which creates technical debt and hinders the release of new features.
Fragmented (point) solutions automate only individual steps, leaving integration seams vulnerable. True acceleration requires a transition to platform engineering, where the architecture is based on a unified declarative metadata model, allowing engineers to focus on business logic rather than routine tasks.
The "infrastructure glue" trap: why point scripts slow down the enterprise
In many organizations, automation has historically developed in a fragmented manner. Instead of a standardized internal developer portal (IDP), teams create custom deployment scripts for every microservice. According to industry estimates, only 13% of companies consider their level of automation to be fully integrated. About 75% of corporate IT teams admit that routine tasks are the primary barrier to rapid releases.
A typical example of "infrastructure glue" is the manual writing and maintenance of CRUD APIs for every new table. When a new field is added, a developer must modify the relational database, update ORM models, rewrite endpoints, and duplicate security and validation rules across the database, backend services, and client interface. Any error in this chain of manual actions leads to data inconsistencies, testing delays, and increased technical debt. Point solutions are necessary for prototyping but become a burden during enterprise scaling.
DORA metrics as an objective compass for development efficiency
To objectively evaluate process efficiency, the industry uses DORA (DevOps Research and Assessment) metrics from Google Cloud, which are the industry standard for measuring software delivery performance. These include: Deployment Frequency, Lead Time for Changes, Change Fail Rate, and Time to Restore Service (MTTR).
DORA research clearly proves that a mature engineering culture and a platform engineering approach correlate directly with faster and more reliable code delivery. Mature DevOps organizations achieve deployment frequencies ranging from several times a day to on-demand. Lead time can be reduced from weeks to days, and in some cases by 49%, through the automation of routine tasks. It is important to understand that DORA metrics are not a direct measurement of business value, but rather indicators of process health. If lead time remains high due to constant integration failures, it is a signal that architectural changes are necessary.
Declarative metadata model: an architectural alternative to manual synchronization
Transitioning to a domain metadata model allows organizations to eliminate manual synchronization. This architectural principle aligns with cloud-native approaches, such as The Twelve-Factor App manifesto, which simplifies continuous delivery and horizontal scaling.
In a metadata-driven architecture, data structure, relationships, user interface, access policies (RBAC/RLS), and system behavior are described declaratively and serve as a single source of truth. Instead of manual coding, the platform automatically generates REST APIs or synchronizes the physical database structure with the defined model. This approach is supported by the Thoughtworks Technology Radar, which identifies platform engineering as a mature strategic direction for modern IT organizations. Implementing platforms does not eliminate the need for developers; it shifts their focus from routine system "gluing" to creating unique business features.
Platform engineering in practice: from database to interface without intermediaries
In practice, platform engineering relies on powerful tools that manage the infrastructure layer. An example is the full-stack JavaScript low-code platform UnityBase (a joint development by the companies of the Intecracy Group, an alliance of independent companies linked by partner agreements and share exchanges). The platform integrates runtime, data layer, security, Admin UI, reporting, BPM, and developer tools around a single domain metadata model.
With UnityBase, developers gain access to:
- Automatic API generation: The platform independently creates ready-to-use REST APIs based on domain entities, eliminating the need to write CRUD code.
- Independent ORM: Automatic generation of DML operations and synchronization of structures with DBMS (PostgreSQL, Oracle, MS SQL Server, etc.).
- Security and audit: Access control rules (RBAC, RLS) and audit trails are applied at the core level, making it impossible to bypass policies via the API.
Enterprise solutions such as the Megapolis.DocNet document management system and the Scriptum (BPM/DMS) low-code solution operate successfully on the UnityBase platform. They achieve minimal time-to-market because developers do not need to write low-level integration code. The domain metamodel automatically ensures synchronization between the database, server logic, and administrator interfaces.
Risk assessment and AWS Well-Architected Framework compliance when choosing a platform
Transitioning to platform solutions requires architectural discipline. The AWS Well-Architected Framework provides a structured approach to identifying risks before they become incidents, focusing on reliability, security, performance, and operational excellence.
When choosing a platform, it is critical to consider security and licensing requirements. In the case of UnityBase, the open-source edition OpenUB (OE) under the Apache License 2.0 is suitable for prototypes, though it carries an official disclaimer regarding use in Ukrainian government agencies. For critical high-load or regulated enterprise systems, official documentation recommends commercial editions. The Enterprise (EE) edition provides support for Oracle RAC, multi-tenancy, and advanced access control (ACL, Attribute-level security). The Defence (DE) edition adds integration with certificate authorities (CRL/OCSP) and support for DSTU signatures. This tiered approach ensures compliance with AWS Well-Architected security standards without excessive costs during the initial stages.
Software delivery maturity levels: from chaotic scripts to platform engineering
| Maturity Level | Characteristics |
|---|---|
| Level 1: Ad-hoc automation | Manual CRUD writing, unique bash scripts for every release, high change fail rate. |
| Level 2: Standardized CI/CD | Presence of build pipelines, but database schemas, APIs, and UI are synchronized manually by developers. |
| Level 3: Platform approach (Platform Engineering) | Use of internal developer portals (IDP), automatic generation of the infrastructure layer. |
| Level 4: Metadata-driven architecture | Full synchronization of DB, API, and UI based on a single domain metadata model, minimal time-to-market. |
FAQ
How does the implementation of platform engineering affect the Lead Time for Changes metric?
Platform engineering handles routine tasks related to infrastructure setup, deployment, and integration synchronization. This allows developers to focus on business logic, which in practice helps organizations reduce Lead Time for Changes from several weeks to a few days (or even hours).
What is the difference between low-code for rapid prototyping and a declarative metamodel for enterprise systems?
Typical rapid prototyping tools can create closed environments that are unsuitable for scaling. A declarative metamodel, such as that in the full-stack JavaScript platform UnityBase, describes the domain by generating APIs and UI, but leaves developers in control of the code, DBMS management, and integrations, which is critical for high-load enterprise environments.
How can security compliance (AWS Well-Architected) be ensured during automatic API generation?
In mature platforms, security is integrated into the core of the domain metamodel. For example, Role-Based Access Control (RBAC) and Row-Level Security (RLS) rules are automatically applied to all generated API endpoints. This ensures data integrity and prevents security policies from being bypassed even when new interfaces are created.