Run-time vs Source-based Analysis
January 16, 2017
Deep Architecture: Moving Beyond UML
July 26, 2017

Introducing Integral: A Platform for Real-Time Architecture

This post is also available as a pdf

Introducing Integral: A Platform for Real-Time Architecture

How many times have you been confronted with out-of-date or useless software architecture documentation? Despite our best efforts as technologists, we are invariably faced with information skew as systems evolve. Even when that documentation is relatively fresh, it’s often incomplete as the effort to produce it is so time-consuming. It doesn’t take long to realize that code is the only reliable source of truth about our applications.

At we have designed and built our flagship product, Integral, to solve precisely those problems. Integral is a platform for what we like to term “real-time architecture”: A Software-as-a-Service and self-hosted offering that helps IT teams track, visualize, understand, and manage enterprise architectures as they change.

Integral starts from source code to build a holistic picture of your enterprise architecture from APIs to backend systems. The following is a view generated by Integral for an online commerce system consisting of multiple distributed services:

While Integral is able to show the connections between applications, it is equally adept at diving into the specifics of modules, wiring, and class-level design of individual services. Integral possesses a multilayered understanding of the underlying frameworks, libraries, and programming models we use every day to build applications. Below is a layered diagram generated by Integral of the Spring Framework website back-end:

Integral diagrams are fully interactive and generated in a continuous fashion: as new versions of applications are developed, changes are immediately applied to create an updated view of your systems.

The technical foundations of Integral rest on three pillars: (1) Deep Architecture Analysis; (2) Active Data Aggregation; and (3) Extensibility. We will outline each of these in the current blog entry with more detailed explanations in subsequent sections and articles.


Deep Architecture Analysis


Integral’s Deep Architecture Analysis beings with the ability to import and analyze source code directly from an organization’s version control system. Unlike traditional modelling tools, which are often restricted to UML-based class analysis, Integral is able to infer relationships at the programming model and framework levels of an application.  Consider the following method from a Spring OrderService bean:


public void create(final Order order) {

orders.put(order.getItem(), order);


        RestTemplate restTemplate = new RestTemplate();

        HttpHeaders headers = new HttpHeaders();


        HttpEntity entity = new HttpEntity("{\"item\":\"1234\",\"quantity\":1}", headers);

        ResponseEntity result = restTemplate.postForEntity(SHIPPING, entity, String.class);

        jmsTemplate.send(SUPPLIER_QUEUE, new MessageCreator() {

            public Message createMessage(Session session) throws JMSException {

                return session.createTextMessage(order.getItem() + ":" + order.getQuantity());





Since Integral has knowledge of the Spring Framework API and programming model, it is able to determine that the bean is wired to another AuditService bean, messages via JMS to a SupplierService bean, and communicates with a REST endpoint. The resulting diagram reflects this wiring:

The ability to analyze these higher-level relationships is akin to “vertical depth”. These areas of application architecture are typically invisible to traditional code analysis tools which focus on the class and OO structure of an application.

Deep Architecture Analysis also includes “horizontal depth”. Integral is able to map inter-application communications, whether they occur over HTTP, JMS, AMQP or other protocols. In the previous example, Integral determines that the OrderService is connected to a REST endpoint backed by a ShippingService contained in another application. This connection is visible in the enterprise architecture diagram created by Integral:

In this case, Integral was able to resolve and match the correct endpoint URLs referenced by the two services.

In future blog entries, we will go into the details of Deep Architectural Analysis and the technologies behind it.


Active Data Aggregation

We named our product “Integral” because architectural knowledge is dispersed throughout an organization and there is a need to both tie together and disseminate that information. For example, have you ever wanted the ability to be notified when a new client application comes online and connects to a service or API? Or, would you like to be notified when an application depends on a certain library? Integral offers users the ability to define triggers which fire events based on certain conditions. Triggers may send notifications to a chat channel, email, or take some other action.

In addition to triggers, Integral also provides the ability to define channels. A channel is a connection to an external information source that provides architecturally relevant information. For example, we are currently working on channels for indexing external documentation sources and runtime metrics data. This information will be seamlessly overlaid onto Integral’s diagramming capability.

Again, future blog entries will demonstrate how channels and triggers work.


Enterprise systems are perhaps best likened to a tower of Babel. While we often aspire to standardize on a common set of technologies, in practice applications tend to be built using an amalgam of frameworks, libraries, and languages. Although we have initially focused on Java-based applications, Integral is designed for a polyglot world. Support for .NET is near and there are plans to support additional languages such as Node.js. This will make it possible to better manage your enterprise architecture whether it is built using a consistent set of technologies or is more heterogeneous in nature.

To achieve polyglot support, Integral relies on a language agnostic representation of applications and services we term the service model. The service model is designed to represent the details of an application – its wiring, endpoints, messaging destinations, etc. – as well as the connections between applications. The model itself is extensible (and serializable to JSON) so it is able to accommodate diverse communications protocols, messaging patterns, and code structures.  As the model matures, we will expose it for customers to query their applications against in order to build their own custom analysis tooling.

Again, we will discuss the details of the Integral service model in future articles.

About, Inc. offers the first platform for real-time architecture. Free trials, downloads, and video demos are also available for Integral, which allows you to make code the source of truth.


Comments are closed.