The Future of Data Storytelling Formats: Beyond Dashboards

Image by Author

# Introduction

 
Historically, dashboards have been the core of data visualizations. This made sense, as they were scalable: one centralized space to track key performance indicators (KPIs), slice filters, and export charts.

But when the goal is to explain what changed, why it matters, and what to do next, a grid of widgets often turns into a "figure-it-out" experience.

Now, most audiences expect stories instead of static screens. In an era of low attention spans, it is important to grasp people's attention. They want the insight, but also the context, the build-up, and the ability to explore without getting lost.

For this reason, data storytelling has moved beyond simple dashboards. We have entered a new era of experiences that are guided (interactive narratives), spatial (augmented reality (AR) / virtual reality (VR) visualizations), multi-sensory (sonification of data), and deeply exploratory (immersive analytics).

Image by Author

# Why Dashboards Are Reaching Their Limits

 
Dashboards are very useful if we want to monitor metrics and KPIs, but they struggle with interactive exploration and true storytelling. Some common limitations include:

• They lose context. A chart might show that something went up or down, but not why.
• They overwhelm. Too many visuals in one place lead to cognitive overload.
• They are passive. Users look but do not interact much with the data.

Today's audience wants more than this. They do not want to see just numbers on a screen.

If you want to practice turning raw datasets into real business narratives — not just charts — platforms like StrataScratch are a great way to build that storytelling intuition through real-world SQL and analytics problems.

They are looking for stories, complete with context, flow, interaction, and even a little drama.

Let's explore four exciting directions where data storytelling is heading.

# Interactive Narratives: Letting Data Unfold Like A Story

 
Imagine if your charts told a story one chapter at a time. That is the magic of interactive narratives. They merge storytelling structure with the liberty to explore.

// How Interactive Stories Actually Work (Scrolls, Steps, And Scenes)

A common and interesting pattern these days is scrollytelling, which combines scrolling and storytelling. This is an online storytelling technique where content is revealed as the user scrolls down the page. It mirrors the behavior users are used to today when scrolling through their favorite social media websites.

Another common pattern is a stepper story, which is the one we will explore in more detail here. The user clicks from step to step to see the story develop. An example of a stepper story could go like this:

• Step 1 explains what is happening (e.g. overview trend)
• Step 2 highlights a change point (can be a simple annotation)
• Step 3 compares segments (filters or small multiples)
• Step 4 proposes an action (what to investigate next)

// Stepper Example With Plotly

This example creates a small dataset and turns it into a narrative using buttons where each button reveals a different "chapter" of the story.

import pandas as pd
import numpy as np
import plotly.graph_objects as go

# Sample data: weekly signups with a campaign launch at week 7
np.random.seed(7)
weeks = np.arange(1, 13)
signups = np.array([120, 130, 125, 140, 150, 148, 210, 230, 225, 240, 255, 260])
baseline = np.array([120, 128, 126, 135, 142, 145, 150, 152, 155, 158, 160, 162])

df = pd.DataFrame({"week": weeks, "signups": signups, "baseline": baseline})

Let's inspect the synthetic data first:

Now let's create the interactive plots:

fig = go.Figure()

# Trace 0: actual signups
fig.add_trace(go.Scatter(
    x=df["week"], y=df["signups"], mode="lines+markers",
    name="Signups", line=dict(width=3)
))

# Trace 1: baseline (hidden initially)
fig.add_trace(go.Scatter(
    x=df["week"], y=df["baseline"], mode="lines",
    name="Baseline (no campaign)", line=dict(dash="dash"),
    visible=False
))

# Narrative steps using buttons
fig.update_layout(
    title="Interactive Narrative: What changed after the campaign?",
    xaxis_title="Week",
    yaxis_title="Signups",
    updatemenus=[dict(
        type="buttons",
        direction="right",
        x=0.0, y=1.15,
        buttons=[
            dict(
                label="1) Overview",
                method="update",
                args=[{"visible": [True, False]},
                      {"annotations": []}]
            ),
            dict(
                label="2) Highlight change",
                method="update",
                args=[{"visible": [True, False]},
                      {"annotations": [dict(
                          x=7, y=df.loc[df["week"]==7, "signups"].iloc[0],
                          text="Campaign launch", showarrow=True, arrowhead=2
                      )]}]
            ),
            dict(
                label="3) Compare to baseline",
                method="update",
                args=[{"visible": [True, True]},
                      {"annotations": [dict(
                          x=7, y=df.loc[df["week"]==7, "signups"].iloc[0],
                          text="Uplift vs baseline starts here", showarrow=True, arrowhead=2
                      )]}]
            ),
        ]
    )]
)

fig.show()

Output:

We can see that interactive buttons turn one chart into a guided story. It is obvious why this type of visualization captivates the public's attention.

This kind of chart works well for product adoption, quarterly reports, investor updates, and other cases where you want to guide the audience. In a nutshell, it is a useful technique when you want people to understand the main point step by step.

# AR And VR Visualizations: Turning Data Into A Space You Can Explore

 
AR adds data on top of the real world. For example, one can see numbers or charts on top of real machines or buildings.

VR puts you inside a fully digital world. You can move around and explore the data as a virtual space.

Both types of visualizations use 3D space to show data as an environment. The point is not just to look cool, but to make relationships like distance, size, and groups easier to understand.

// Where AR/VR Are Useful

• When we aim to display information directly on physical hardware.
• When we want to walk around and see how buildings or cities might look in different situations.
• When we want to investigate simulations, outer space, or microscopic worlds in three dimensions.
• When individuals wish to navigate transformations, test concepts, and evaluate outcomes prior to committing to real-world actions.

Image by Author

// A VR-Ready 3D Bar Chart

Here we use A-Frame and WebXR to build a small 3D bar chart that runs in the browser. Every bar is one category, and taller bars mean higher values.

The scene runs on a regular desktop browser or in a VR headset that supports WebXR. There is no complex setup needed.

The output, in the browser, looks like this:

How to run this example locally:

1. Save the file as vr-bars.html
2. Open a terminal in the same folder
3. Start a simple local server with Python: python -m http.server 8000
4. Open your browser and go to: http://localhost:8000/vr-bars.html

It is better to open the file through a local server because some browsers restrict WebXR features when trying to open raw HTML files directly.

# Sonification: When Data Becomes Sound

 
Sonification means turning data into sound. The numbers can become high or low sounds, loud or quiet sounds, or even short and long sounds.

One might think this adds nothing to our data visualization dynamics. However, sound can help us notice patterns, changes, or problems, especially if the data changes over time.

// The Best Use Cases For Sound-Based Data Insights

• Monitoring systems (strange or unusual sounds are easy to notice)
• Accessibility (sound helps people who cannot rely only on charts or visuals)
• Dense time series (rhythms make patterns and sudden spikes easier to hear)

Image by Author

// Turning A Time Series Into Tones

Here, each value is turned into a musical pitch. The notes are simple sine sounds, with small gaps between them to make the sequence clearer.

This version is for a Jupyter notebook (or JupyterLab / Google Colab). It uses IPython.display.Audio to play the sound directly in the output cell, so there is no need to install system audio libraries.

import numpy as np
from IPython.display import Audio, display

# Example: daily website visits (small time series)
visits = np.array([120, 118, 121, 130, 160, 155, 140, 138, 200, 180])

min_f, max_f = 220, 880  # A3 to A5
v_min, v_max = visits.min(), visits.max()

def scale_to_freq(v):
    if v_max == v_min:
        return (min_f + max_f) / 2
    return min_f + (v - v_min) * (max_f - min_f) / (v_max - v_min)

sample_rate = 44100
note_dur = 0.18  # seconds per note
gap = 0.03       # silence between notes

audio_all = []

for v in visits:
    freq = scale_to_freq(v)
    t = np.linspace(0, note_dur, int(sample_rate * note_dur), endpoint=False)
    tone = np.sin(2 * np.pi * freq * t)

    # Fade out to reduce clicks
    fade = np.linspace(1, 0, len(tone))
    tone = 0.3 * tone * fade

    audio_all.append(tone)
    audio_all.append(np.zeros(int(sample_rate * gap)))

audio = np.concatenate(audio_all)

display(Audio(audio, rate=sample_rate))

You can hear the output here.

Click play to hear it. When the visit count is higher, the sound is higher too, making spikes easy to hear.

To transform it into a more storytelling vibe, add a small line chart and highlight important moments like spikes, drops, and trend breaks. A useful addition is to play the audio while revealing the line over time, so readers both see and hear the shift.

# Immersive Analytics: Exploring Data By Moving Through It

 
Immersive analytics is when we explore data in a way that is more like moving and touching things, rather than just clicking buttons or filters.

The immersivity comes from:

• Data being shown in 3D or put out in space when it makes things easier to understand
• The ability to move sliders, select parts of the data, and change the view, with the data updating immediately
• Changes in one chart causing other charts to update as well

// Interactive 3D Exploration

This example uses Plotly to show a 3D chart we can turn and filter. It is not a standard dashboard; it is a tool to explore and interact with data.

Run this in a Jupyter Notebook:

import numpy as np
import pandas as pd
import plotly.express as px
import ipywidgets as widgets
from IPython.display import display

# Synthetic multi-dimensional data
np.random.seed(42)
n = 800
df = pd.DataFrame({
    "x": np.random.normal(0, 1, n),
    "y": np.random.normal(0, 1, n),
    "z": np.random.normal(0, 1, n),
})
df["score"] = (df["x"]**2 + df["y"]**2 + df["z"]**2)

slider = widgets.FloatSlider(
    value=float(df["score"].quantile(0.90)),
    min=float(df["score"].min()),
    max=float(df["score"].max()),
    step=0.05,
    description="Score ≤",
    readout_format=".2f",
    continuous_update=False
)

out = widgets.Output()

def render(threshold):
    filtered = df[df["score"] <= threshold].copy()
    fig = px.scatter_3d(
        filtered, x="x", y="y", z="z", color="score",
        title="Immersive analytics (lite): rotate + filter a 3D space",
        opacity=0.75
    )
    fig.update_traces(marker=dict(size=3))
    fig.show()

def on_change(change):
    if change["name"] == "value":
        with out:
            out.clear_output(wait=True)
            render(change["new"])

slider.observe(on_change)

display(slider, out)
render(slider.value)

Here is the output:

To improve this, you can let people select points, show the selected rows in a table, or draw lines around clusters. It works well when you guide the exploration during a meeting. For example, you can start with a step-by-step path, then let the public explore on their own.

# Conclusion

 
The future of data storytelling will not concern the removal of dashboards entirely; instead, we will see a tendency toward more interactive and immersive stories about data, models, and insights.

Image by Author

In a nutshell, here is how one can choose the best type of data visualization:

• Want to guide someone? Try an interactive narrative.
• Need to show spatial relationships? AR/VR can help.
• Hoping to reach more senses? Let your data speak.
• Want to invite exploration? Create an immersive playground.

The best part is that you do not need a big budget or team to try this.

Pick one technique and build a tiny prototype. A little stepper or a 3D bar, a sonified line chart or a slider-based filter. You will be amazed how fast your data starts feeling like a story.
 
 

Nate Rosidi is a data scientist and in product strategy. He's also an adjunct professor teaching analytics, and is the founder of StrataScratch, a platform helping data scientists prepare for their interviews with real interview questions from top companies. Nate writes on the latest trends in the career market, gives interview advice, shares data science projects, and covers everything SQL.