DEV Community

Muhammad Ayyan
Muhammad Ayyan

Posted on

How Does a Metadata-Driven Platform Turn Application Changes into Configuration Rather Than Code Releases?

How metadata repositories, supervised runtime engines and controlled configuration help enterprise applications adapt to changing business requirements.

Introduction

Enterprise applications rarely remain unchanged for long.

A manufacturing company might introduce a new purchase approval policy. A finance department may need additional validation rules. An HR team might change its employee onboarding process, or a sales department may require new fields and approval stages in its CRM system.


These are normal business requirements. However, implementing them can become surprisingly complicated when applications are tightly coupled to traditional development and deployment cycles.

In a conventional code-centric architecture, an application change may involve modifying source code, updating database structures, testing dependencies, building a new version and deploying it to production. Even when the business requirement is relatively small, the technical process can involve several teams and stages.

The problem is not that software releases are unnecessary. Platform upgrades, new runtime capabilities, infrastructure changes and complex functionality still require engineering and controlled releases. The challenge arises when every supported business-level adjustment has to follow the same process.

A metadata-driven platform offers a different architectural approach.

Instead of defining every application component directly in source code, it stores application definitions as structured metadata. A runtime engine interprets these definitions and uses its underlying capabilities to execute application behaviour.

This separates two responsibilities: engineers evolve the platform, while applications evolve through controlled changes to their definitions.

As a result, many application-level adjustments can be made through configuration without compiling and redeploying the entire application.

Why Traditional Application Changes Can Become Expensive

Consider a manufacturing company that uses an enterprise application to manage purchase orders.

Initially, its approval process is straightforward:

  • An employee submits a purchase order.
  • The department manager reviews it.
  • The finance team approves it.
  • The order moves to processing.

After a few months, management introduces a new policy: purchase orders exceeding $10,000 must also receive approval from the procurement director.

In a conventional code-centric implementation, introducing this requirement could involve:

  • Updating the application's approval logic.
  • Modifying database structures if the requirement needs additional information.
  • Adjusting the user interface.
  • Updating role permissions.
  • Testing existing and new workflows.
  • Building and deploying an updated application version.

The actual business requirement is relatively simple, but the technical process may involve source-code changes, dependency checks, testing and deployment coordination.

The impact becomes more significant when an organization operates several interconnected applications, including ERP, CRM, HR, inventory and project management systems.

A change to one business process may affect other components, data structures, permissions and reports.

This does not mean every conventional application requires a complete software release for every adjustment. Modern applications can also use configuration files, feature flags, dynamic rules and other runtime mechanisms. The architectural distinction is how extensively the application itself is defined and executed through metadata.

A metadata-driven architecture makes that separation a fundamental part of the platform rather than treating configuration as an additional feature.

What Is a Metadata-Driven Platform?

A metadata-driven platform uses structured information, known as metadata, to define an application's structure and behaviour.

Rather than implementing every application component as an independently compiled piece of source code, the platform stores definitions that describe how those components should operate.

Depending on the platform's capabilities, metadata can define:

  • Data Models: Business entities, fields, relationships, data types and validation rules.
  • User Interfaces: Forms, screens, layouts, components and navigation structures.
  • Business Rules: Conditions, calculations, validation requirements and transaction logic.
  • Workflows: Approval processes, task assignments, triggers and workflow transitions.
  • Security: User roles, access permissions and restrictions on business information.
  • Reports and Dashboards: Data sources, filters, calculations and presentation definitions.

These definitions are stored in a metadata repository. A runtime engine interprets them and provides the execution capabilities required to run the application.

The distinction is fundamental: metadata describes what an application should do, while the runtime provides the mechanisms through which that behaviour is executed.

Metadata Repository, Runtime Engine and Execution Infrastructure

Understanding a metadata-driven platform requires distinguishing three architectural responsibilities.

1. Metadata Repository

The metadata repository stores application definitions. These may include data structures, screen configurations, workflow conditions, roles, endpoints and reporting definitions.

It provides a structured source from which the runtime can retrieve application metadata.

2. Runtime Engine

The runtime engine interprets the stored definitions and materializes the application components when they are needed.

For example, it can use a screen definition to generate an interface, evaluate a configured validation rule or execute a workflow transition.

3. Execution Infrastructure

The execution infrastructure provides the services required to operate the runtime reliably. Depending on the architecture, these may include request processing, thread management, database connections, sessions, security enforcement, caching and audit mechanisms.

These responsibilities work together. A metadata repository alone cannot execute an application, and a runtime engine needs the infrastructure to process application requests and manage execution.

This separation is what allows a platform to support multiple applications without requiring each one to implement its own complete execution foundation.

How Configuration Replaces Many Application-Level Code Changes

The main architectural difference is where application behaviour is defined.

In a code-centric implementation, developers often implement individual business requirements directly in application source code.

In a metadata-driven implementation, reusable platform capabilities are already available through the runtime. Application definitions determine how those capabilities are configured and used.

Return to the manufacturing company's purchase approval requirement.

The company wants to introduce an additional approval stage for orders exceeding $10,000.

A metadata-driven implementation could involve:

  • Updating the purchase-order approval condition.
  • Configuring the additional approval stage.
  • Assigning approval responsibility to the procurement director's role.
  • Defining the workflow transition.
  • Validating the updated configuration.
  • Making the updated definition available to the runtime.

When a purchase order is submitted, the runtime evaluates the configured condition.

If the order exceeds $10,000, the additional approval stage is activated. If it does not, the transaction follows the existing approval path.

The underlying runtime engine does not need to be rebuilt simply because the business approval policy has changed.

This is the central idea behind configuration-driven application development: supported business requirements are expressed through application definitions rather than requiring every adjustment to become a new software build.

However, configuration has boundaries. If the new requirement needs an execution capability that the platform does not already support, engineers may still need to develop that capability at the platform level.

The Runtime Engine: Turning Metadata into Application Behaviour

A metadata repository stores definitions, but those definitions become useful only when a runtime can interpret and execute them.

The runtime engine is therefore more than a component that reads configuration. It is the execution foundation responsible for turning application definitions into working enterprise software.

Consider what happens when a user interacts with an application:

  • A user opens a form, and the runtime retrieves and materializes its interface definition.
  • A transaction is submitted, and the runtime evaluates the relevant validation rules.
  • An approval condition is satisfied, and the workflow engine executes the configured transition.
  • A user requests a record, and the security layer evaluates the applicable permissions.
  • An application invokes a configured endpoint, and the runtime processes the request using its execution context.

In an enterprise environment, these operations also depend on services such as authentication, authorization, tenant context, data access, transaction management, session handling and audit.

A well-designed runtime manages these responsibilities consistently instead of requiring every application to implement them independently.

Why a Supervised Runtime Matters

A shared runtime can reduce duplicated functionality, but sharing execution infrastructure also creates an important responsibility: applications must operate within the controls established by the platform.

A supervised runtime owns critical execution services and provides applications with controlled access to them.

For example, it can manage incoming HTTP requests, execution threads, database connection pools, sessions, security enforcement and audit mechanisms.

This matters because an enterprise platform may run multiple applications and business processes within the same underlying environment. Security, tenant boundaries and operational controls should not depend entirely on individual application developers remembering to implement them correctly.

The runtime should enforce the platform's execution rules consistently.

The architecture therefore separates application flexibility from infrastructure control: application definitions can evolve while the platform maintains responsibility for how those definitions are executed.

Why a Shared Metadata Repository Matters

A metadata repository provides a central place to maintain application definitions.

Without a consistent repository, different application components may maintain separate versions of business rules, permissions and data structures. This can create synchronization problems and make changes harder to manage.

For example, imagine an enterprise changes the definition of a customer record.

That change may affect:

  • CRM customer screens.
  • Sales and customer-management workflows.
  • Customer-related validation rules.
  • Reporting structures.
  • Connected business processes.

A shared metadata model can help maintain consistency across these components by providing a common source of application definitions.

This becomes especially valuable when an organization operates multiple enterprise applications, including:

  • Enterprise Resource Planning (ERP).
  • Customer Relationship Management (CRM).
  • Human Resource Management (HR).
  • Project Management.
  • Procurement and Inventory Management.
  • Business Intelligence and Reporting.

Instead of maintaining completely separate application foundations, organizations can use shared platform capabilities to support different business functions.

The value is not simply having all application definitions in one location. It is having a consistent runtime model that interprets and manages those definitions across the application environment.

What Happens When Metadata Changes in a Running Application?

One of the most important architectural questions is how updated metadata becomes available to an application that is already running.

A basic implementation might reload definitions whenever an application restarts. However, this approach reduces the practical benefits of configuration-driven development.

More advanced architectures use metadata caching and cache invalidation mechanisms to make updated definitions available without restarting every runtime instance.

Consider an application running across multiple runtime nodes.

Each node may maintain its own in-memory metadata cache. This avoids repeatedly retrieving the same definitions from the metadata repository and can reduce unnecessary database access.

However, it also introduces a consistency challenge: when an authorized user updates a screen or workflow, other runtime nodes must stop relying on outdated cached definitions.

Distributed Cache Invalidation

One approach is to use a messaging mechanism such as Redis Pub/Sub to communicate cache-invalidation events across runtime instances.

The process can be understood through the following sequence:

  1. An authorized user updates an application definition.
  2. The updated definition is saved in the metadata repository.
  3. The platform publishes a cache-invalidation event.
  4. Connected runtime nodes receive the event and clear the relevant local cached metadata.
  5. The next applicable request retrieves and uses the updated definition.

This allows connected runtime instances to respond to metadata changes without requiring a full application restart.

For example, when a purchase approval workflow is updated, the relevant runtime nodes can invalidate their cached workflow definition. Subsequent requests can then use the updated approval configuration.

Airtool's published architecture describes a two-tier metadata caching model: local in-memory caches at runtime nodes and Redis Pub/Sub for cluster-wide cache invalidation.

An Important Consideration: Message Delivery and Cache Consistency

Distributed cache invalidation requires more than broadcasting a message.

Redis Pub/Sub uses at-most-once delivery semantics. A subscriber that is disconnected or unable to process a message can miss that message; Redis does not automatically replay it later.

This means Pub/Sub should be understood as a notification mechanism, not as a durable event log.

A production architecture must consider how it handles missed notifications, reconnects and metadata consistency. Depending on the design, this may involve reconciliation against durable metadata state, version checks, refresh mechanisms or another recovery strategy.

The specific recovery mechanism must be established from the platform's implementation rather than assumed from the use of Redis Pub/Sub alone.

There is also an important distinction between requests already in progress and new requests. Airtool's published developer-experience documentation explains that in-flight requests continue using the version they loaded, while subsequent applicable requests use the updated definition.

This allows a metadata change to become available without forcibly interrupting every active request.

Cache invalidation therefore helps distribute changes efficiently, but it does not replace metadata validation, version management or change governance.

Configuration Does Not Mean the Absence of Governance

Making application changes easier should not mean making them uncontrolled.

In enterprise environments, even a small configuration change can affect financial transactions, customer records, employee information and operational processes.

A reliable metadata-driven platform should therefore provide appropriate governance mechanisms.

Configuration Validation

Changes should be checked before becoming active to identify invalid definitions, missing dependencies and incompatible settings.

Version History

Organizations should be able to identify previous configurations and understand how application definitions have evolved.

Audit Trails

The platform should record who changed a definition, what was changed and when the change occurred.

Role-Based Access

Only authorized users should be allowed to modify sensitive application definitions.

Rollback Capabilities

Organizations should have a controlled way to restore a previously valid configuration when an update causes unexpected behaviour.

Testing and Change Approval

Critical workflows should be tested, and higher-risk changes should follow appropriate approval procedures.

Environment Promotion

Organizations may need to move configuration changes through development, testing and production environments. This requires a controlled approach to promoting definitions and managing differences between environments.

It is also important to distinguish configuration versioning from platform release management. Application definitions may change independently, but the runtime and its underlying services still need their own versioning, testing and upgrade procedures.

The objective is not to remove change management. It is to make application changes easier to manage without compromising reliability, security or operational control.

How Airtool Implements a Metadata-Driven Application Model

Airtool provides an example of an enterprise application platform built around a metadata-driven runtime.

Its architecture treats application components as definitions stored in a Metadata Repository rather than relying on independently compiled application artefacts for every application-level change.

According to Airtool's published architecture, elements such as tables, screens, endpoints, roles and reports are represented as Metadata Repository records. The runtime materializes the application surface from these definitions during execution.

This changes how application updates are handled.

When an authorized user modifies a supported application definition, the change is saved as metadata. Airtool's two-tier caching model uses local in-memory caches at runtime nodes and Redis Pub/Sub to communicate cache-invalidation events across the cluster.

The affected runtime nodes invalidate their cached definitions. Subsequent applicable requests can then use the updated metadata without requiring a conventional JAR rebuild, application redeployment or node restart.

Airtool's developer-experience documentation also describes how existing in-flight requests continue using the version they loaded, while subsequent requests use the updated definition.

This is an important architectural distinction: application-level definition changes are separated from upgrades to the underlying platform runtime.

One Runtime Across the Enterprise Application Environment

Airtool's architecture is not limited to a single business application.

Its enterprise application platform provides a shared runtime foundation for ERP, CRM, HR and Project Management applications. These applications use the same underlying platform rather than relying on completely independent execution foundations.

The platform also describes a five-layer architecture comprising the web browser, applications, application platform, core infrastructure and data tier.

Within this model, the application-platform layer contains the Metadata Repository runtime, while the underlying infrastructure provides services such as HTTP processing, virtual threads, data access and caching.

This gives the architecture a clear separation of responsibilities: applications define business functionality, the runtime materializes and executes those definitions, and the underlying platform manages the infrastructure required to run them.

For organizations interested in the technical implementation, Airtool's metadata-driven enterprise application architecture explains its runtime, metadata repository and execution model. Its developer experience documentation provides further detail on authoring and hot-reload behaviour.

Metadata Configuration vs. Traditional Code Releases

It is important to understand that metadata-driven architecture does not eliminate software engineering.

The distinction is between application-level changes that can be expressed through existing platform capabilities and platform-level changes that require engineering work.

Type of change Metadata-driven approach Typical code-centric approach
Add a supported application form field Update the metadata definition May require application and database changes
Change screen layouts Update interface metadata May require UI source-code changes
Update supported approval conditions Modify workflow configuration May require business-logic changes
Modify supported workflow transitions Update workflow definitions May require workflow implementation changes
Change application role assignments Update role and permission definitions May require application configuration or code changes
Introduce a new runtime capability Platform engineering and release Platform engineering and release
Fix a runtime engine defect Platform code release Platform code release
Upgrade core infrastructure Platform upgrade Platform upgrade

These are typical architectural patterns, not universal rules. Conventional applications can also support dynamic configuration, and some metadata-driven changes may still require code or database migrations.

The important difference is how much of the application's structure and behaviour can be managed through metadata and how much depends on changes to the underlying runtime.

A well-designed architecture establishes a clear boundary between the two.

Architectural Considerations and Trade-Offs

Metadata-driven architecture can make enterprise applications more adaptable, but it also introduces engineering responsibilities that should be addressed deliberately.

Metadata Schema Evolution

Application definitions change over time. A platform needs a strategy for evolving metadata schemas while maintaining compatibility with existing definitions and runtime versions.

Runtime Compatibility

An updated metadata definition must be compatible with the runtime capabilities available to execute it. A configuration should not assume that a runtime supports functionality it does not provide.

Cache Consistency

Distributed runtime instances may maintain local copies of metadata. The platform needs a reliable strategy for invalidation, refresh and recovery when nodes miss notifications or temporarily lose connectivity.

Configuration Validation

A definition may be syntactically valid but still create incorrect business behaviour. Validation should consider dependencies, permissions, workflow paths and business rules.

Concurrent Changes

Multiple authorized users or development teams may modify related definitions. The platform should provide appropriate controls for detecting conflicts and managing concurrent updates.

Testing and Promotion

Configuration changes can affect production transactions just as code changes can. Critical changes should be tested and promoted through controlled environments where appropriate.

Performance and Caching

Interpreting metadata introduces execution and retrieval considerations. Effective caching, query management and runtime design are important to prevent configuration flexibility from creating unnecessary overhead.

These considerations do not undermine the metadata-driven approach. They define the engineering quality required to make it suitable for enterprise workloads.

The objective is not simply to replace source code with metadata. It is to build a runtime and governance model capable of managing metadata as executable application definitions.

Business Benefits of Metadata-Driven Application Development

When implemented properly, a metadata-driven platform can provide several practical advantages.

Faster Adaptation to Business Requirements

Organizations can adjust supported application definitions without waiting for a complete software release cycle.

Reduced Repetitive Development

Reusable runtime capabilities reduce the need to implement similar functionality separately across multiple applications.

More Consistent Application Management

Centralized definitions and shared platform services can make it easier to maintain common rules, permissions and workflows.

Simplified Application Maintenance

Application-level configuration can be managed independently from the underlying platform's software lifecycle.

Improved Enterprise Flexibility

A shared runtime foundation can support different applications and business processes while maintaining consistent execution patterns.

Better Change Visibility

Version history, audit records and approval controls help organizations understand and manage application changes.

These benefits depend on the capabilities of the underlying platform. Metadata-driven architecture is not automatically faster, safer or more reliable. The runtime, caching strategy, security model and governance mechanisms determine how well it works in practice.

Frequently Asked Questions

What is a metadata-driven application?

A metadata-driven application is an application whose structure and supported behaviour are defined through stored metadata rather than being implemented entirely as fixed source-code components. A runtime engine interprets those definitions and executes the application.

What is the difference between metadata-driven and code-driven development?

In code-driven development, application behaviour is commonly implemented through source code and compiled or deployed as part of an application release. In metadata-driven development, supported application structures and behaviours are stored as definitions that a runtime interprets. Both approaches still require software engineering, but they distribute responsibilities differently.

Does metadata-driven architecture eliminate software releases?

No. It can eliminate conventional build and deployment steps for supported application-level changes. New runtime capabilities, infrastructure upgrades, complex integrations and runtime defect fixes may still require engineering work and platform releases.

What is the role of a metadata repository?

A metadata repository stores structured application definitions, such as data models, screens, workflows, business rules, roles and endpoints. The runtime retrieves and interprets these definitions to execute the application.

How does a runtime engine execute application metadata?

The runtime retrieves the relevant definitions, interprets their configuration and uses its underlying execution services to materialize application components and process business operations. These services may include request handling, validation, workflow execution, data access and security enforcement.

How does Redis Pub/Sub support metadata cache invalidation?

Redis Pub/Sub allows a platform to broadcast cache-invalidation notifications to connected runtime instances. Each receiving node can invalidate the relevant local cached metadata so subsequent requests retrieve updated definitions. Redis Pub/Sub has at-most-once delivery semantics, so a production architecture must also account for disconnected subscribers and missed notifications.

What happens when metadata changes in a running application?

The platform updates the stored definition and makes the change available to the runtime through its metadata-refresh or cache-invalidation mechanism. The exact behaviour for active requests depends on the platform. In Airtool's published developer-experience documentation, in-flight requests continue using the version they loaded, while subsequent applicable requests use the updated definition.

Can metadata-driven platforms support enterprise applications?

Yes. A metadata-driven platform can support enterprise applications such as ERP, CRM, HR and Project Management when its runtime provides the necessary capabilities for data management, workflows, security, integration, transaction processing and operational control. Suitability depends on the platform's actual architecture and implementation.

How does Airtool use metadata-driven architecture?

Airtool stores application components such as tables, screens, endpoints, roles and reports as Metadata Repository records. Its runtime materializes application components from these definitions. AirTool also describes a two-tier metadata caching approach using local in-memory caches and Redis Pub/Sub for cluster-wide cache invalidation.

Final Thoughts

The evolution of enterprise application development is not simply about writing less code. It is about separating business requirements from the underlying software infrastructure.

Traditional code-centric architectures remain valuable for building platform capabilities, developing complex functionality and maintaining core software systems. However, requiring a complete development and deployment cycle for every supported application-level adjustment can create unnecessary operational overhead.

Metadata-driven platforms provide another approach.

By storing application definitions as structured metadata and using a runtime engine to interpret them, organizations can manage many business-level changes through controlled configuration.

The real architectural advantage is the separation of two responsibilities: engineers evolve the platform, while applications evolve through configuration.

When supported by a capable runtime, effective caching, consistent security enforcement and disciplined change governance, this approach can make enterprise software more adaptable, maintainable and responsive to changing business requirements.

Top comments (0)