# Unlocking the Past of Your Data: From Static JSON to Temporal Graph

**In this post I’m going to use much of the material presented to me by** [**Thor Henning Hetland**](https://www.linkedin.com/in/thorhenninghetland/) **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.  

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1763880227133/2cee4c2e-4df0-4b33-aa29-6023f0256369.webp align="left")

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:

```graphql
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:

```graphql
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**](http://exoreaction.com).

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