In this post I’m going to use much of the material presented to me by Thor Henning Hetland on Temporal Intelligence and how it has been implemented in practice.

Take notes — and feel free to send us your comments, or reach out if you’re interested in a demo for your company.

Have you ever looked at a spreadsheet or a database and felt like you were only seeing a tiny piece of the story?

Most of our data is just a static snapshot, right?
A single frame of a much, much longer movie.

Well, today we’re going to flip that completely.

We’re going to learn how to transform those flat, static records into a living story — a time machine we can query not only to understand what is true now, but what was true at any moment in the past.

The Problem: The Blind Spot of Time

Most of the data we work with every day — user profiles, product inventory, you name it — is designed to tell us the current state of things.

But in doing so, it creates a massive blind spot:
the entire dimension of time.

As you look at a typical data record, I want you to ask just one question:

👉 What story is this data not telling me?

What critical questions can we not answer with the information we see right now?

A Real Example

Imagine a simple JSON record for a company: Acme Technology AS.
We can see its name, founding date, and how many employees it has.

That’s fine for knowing what is true today, but it tells us nothing about:

• How many employees it had last year

• Whether it was owned by another company five years ago

• How its corporate structure evolved over time

This is just a photograph — when what we really need is the entire movie.

The Solution: The Temporal Graph

So how do we capture that full movie?

Simple:
We build a time machine for our data.

And that time machine is called a temporal graph.

What Is a Temporal Graph?

Think of it like this:

A temporal graph is a special kind of database that doesn’t just store what is true now.
It stores everything that has ever been true.

Every piece of information, every relationship, has a lifetime:
valid_from and valid_to.

It’s like having the full history book of your data, not just the last chapter.

The Process: From Static Files to Temporal Graph

You can visualize the transformation as an assembly line that brings time to your static data.

The infographic illustrates this pipeline perfectly (referring to the one you mentioned).

Here’s the four-step blueprint:

Step 1: Ingestion

We stream raw data efficiently, without loading huge files into memory.
We take our static JSON files (for example, from a business registry) and prepare them for processing.

Step 2: Mapping

This is where the real magic happens — the exact moment time enters the picture.

We use a transformation language called JSLT to take a field from the source data — say, the company’s founding date — and map it to a special field called valid_from.

And just like that:
👉 our data becomes time-aware.

Step 3: Sourcing

We store events as a permanent, immutable record — our source of truth.

Every event, with its timestamp, is preserved forever so history can never be lost.

Step 4: Projection

We build the temporal graph in a database like Neo4j.
Aurora, the temporal graph engine, takes all timestamped events and constructs the graph.

And here’s the key:

Every entity — every company node, every subsidiary relation — receives two special properties:

• valid_from

• valid_to

These two values are the secret sauce that make historical queries possible.

Time Queries: Turning On the Time Machine

Our temporal graph is built.
The entire history is encoded within it.

Now comes the reward.
Let’s fire up our new time machine.

Point-in-Time Queries

Suppose we want to know which companies existed in Oslo on January 1st, 2020.

With the original static files?
Impossible.

But with our temporal graph?
Trivial.

Here’s the elegant GraphQL query:

query {
  companies(
    at: "2020-01-01"
    where: { postalAddress: { city: "Oslo" } }
  ) {
    name
    employeeCount
  }
}

See that small but powerful parameter at?
That’s the dial of our time machine.

We tell the database:

👉 “Ignore everything that happened after this date. Show me exactly how the world looked at this moment.”

Relationships That Change Over Time

Now let’s ask something more complex — something involving evolving relationships.

Companies buy and sell subsidiaries all the time.
We want to know the exact corporate structure at a point in the past.

It’s incredibly simple:

query {
  companies(
    at: "2021-12-31"
  ) {
    name
    subsidiaries {
      name
    }
  }
}

The engine automatically respects the temporal context.
It only returns relationships valid at that date.

Time travel is built right into the graph.

The Real Value: Beyond the Tech

This is all technically impressive, but… so what?
Why go through all this effort?

Because the payoff is huge.
You can now answer questions that used to be impossible.

Here are the insights that truly matter:

1. Point-in-Time Analysis

Question: “What did the business landscape look like on January 1st, 2020?”

You can now travel to any date and see the exact, real state of your world.

2. Historical Trends

Question: “Show year-over-year growth of companies in Oslo from 2015 to 2025.”

You can observe long-term patterns and build predictive models based on true historical evolution.

3. Root Cause Analysis

Question: “Why did tech startups in this city grow 25% last year?”

Time reveals causes hidden in static data.

A customer churns — you travel back and see:
“Oh, their account manager changed two weeks before.”

Invisible in a static record.
Obvious in a temporal graph.

4. Competitive Intelligence

Question: “When did other cities start competing with Oslo for startups?”

You can detect shifts before they become obvious — and adjust strategy.

5. Compliance & Audit

You can show an auditor the exact state of your system on any date.

Not an approximation.
The real, immutable truth.

Conclusion: Your Data Has a Memory

What this process reveals is powerful:

👉 Your data always had a story to tell — a story of evolution, growth, and change.
We simply didn’t have the tools to listen.

By building a temporal graph, you don’t just store data —
you preserve its memory.

So the final question is simple:

Your data has history. Are you ready to listen to it?

If you want to learn more about how to implement temporal graphs in your organization, the open-source Xorcery framework and its Aurora engine offer a complete solution to transform your static data into a fully queryable time machine.

Feel free to reach out to the team at exoreaction.com.

Author: José Amadeo Díaz Díaz
Date: November 2025