## Performance evidence update / 18 September 2026

MODALITY PERFORMANCE / EVIDENCE REVIEWED 18 SEPTEMBER 2026

Five million readings. Queryable in 2.56 seconds.
Recorded bulk-loading comparison
September 8, 2026 campaign
seconds until queryable
Lower is better · linear scale from zero
8DB
2.56
Four HTTP writers
QuestDB
5.16
One TCP stream

M1, 16 GB; 50 million metric values; median of three rounds. Different client configurations; buffered completion without power-loss-safe loading. Specialized flat bulk path, not the newer typed durable carrier, encrypted throughput or energy measurement.

Read the results, comparison and methods →

What happens when models work together?
See the separate graphs + time series + spatial benchmark against SurrealDB →

01
Ingest-to-queryable time
02
Late data & version fidelity
03
Stored bytes per observation
Include memory, storage, energy and hardware writes

[Read the results, comparison and methods →](/journal/8db-questdb-tsbs-time-to-queryable)
[See the separate graphs + time series + spatial benchmark against SurrealDB →](/modalities#multimodal-performance)

<!-- performance-update-end -->

## Interactive evaluation example / 18 September 2026

[Explore the visual example](/outcomes/observation-decisions#example). [Download the semantic fixture and acceptance checklist](/evaluation/observation-decisions.json). Browser illustration only; not a live 8DB runtime or benchmark. Pin the engine build, platform, adapters and protection scope for an assisted evaluation.

## Implementation update — 18 September 2026


Implementation snapshot / Reviewed 18 September 2026

Keep the observation, the gap and the version.

Merged implementation / internal deployment recorded

The carrier represents points, enclosures, below-detection bounds and typed absence. Its scan reports samples and gaps with coverage, and admits late data against transaction versions. The 14 September status ledger records carrier and algebra merges, reopen checks and internally reached routes.
[See the reading, bound and gap example →](/outcomes/observation-decisions#example)

API, release scope and evidence limits

Documented interfaces: ts_scan(series, lo, hi, as_of); POST /api/time-series/catalog, /write and /scan. Carrier merge 9d79e312; reopen 60ff836e; multiscale merge 7bfd0b08.

Review dated 18 September 2026; no fresh engine run. Customer build, adapter and device qualification remain to confirm. Earlier flat-ingest benchmarks do not measure this typed carrier. Outage classification, retention-expired state and delta compaction have separate recorded limits.



---

# Time series | 8DB

Product reference. Reviewed 18 September 2026. Implementation and evaluation scope are stated below.

Explore the models

(https://8braid.com/modalities)

/ 8DB

Time series

Keep the meaning in every observation.

A measured point, a bounded reading and a missing interval each tell a different story. Preserve that context through storage and analysis.

Explore the capabilities

See a complete workload

Observe · window · analyze

Model /

Time series

Conceptual diagram

[Diagram: time series representation: conceptual diagram]

Measured points, an interval bound and a visible gap retain different meanings along the same timeline.

Why it matters

Capabilities

Alternatives

Performance

Input to value

Connected models

Related articles

Technical reference

The reading is only part

of the evidence.

Consider a sensor that goes quiet and later sends buffered observations. You need to understand both what happened and what was available when a decision was made.

01 / Preserve the observation

Keep a bound as a bound.

8DB distinguishes point values, enclosures, below-detection readings and typed absence. A reading below an instrument’s floor needn’t become a misleading zero.

02 / Explain the gap

Make missing data useful.

Declared cadence and deployment windows distinguish an expected reading from a period when a sensor wasn’t deployed. Gap results can carry a missingness state and a path to obtain the missing evidence.

03 / Revisit the decision

Read what was known then.

Admitted late observations enter as versioned deltas. An as-of-version read lets an application revisit an earlier view rather than silently replacing its history.

These semantics can reduce the custom bookkeeping around telemetry, scientific observations and intermittent devices. Application-level savings and decision outcomes still depend on the workload. Source:

implementation scope

.

From individual observations

to the shape of change.

The carrier preserves the observations. Related 8DB structures let an application ask about coverage, bounds, co-movement and change at different scales.

Work you need to do

8DB capability

What to check for your application

Store and retrieve a series

Typed samples, chunked storage, catalogue metadata and range scans.

Series clock, cadence, deployment windows, codec and the chosen persistence path.

Handle late observations

Transaction-version deltas and as-of-version reads; a refusal policy is available for sealed series.

Late-data policy and whether the requested range is settled.

Summarize uncertainty

Interval-hull rollups with coverage by state.

A hull describes an enclosure. It is not interchangeable with an arithmetic average.

Find similar sequences

Source-backed dynamic time warping search with explicit gap handling.

The supported path either refuses gaps or uses present samples; the carrier does not interpolate them.

Compare co-movement

Rank-crossing braids and topology-based trigger evaluation.

How series become strands; normalization and domain assumptions. Trigger evaluation is per call.

Inspect multiple scales

Trained per-series/window layers with residual information and staleness flags.

The ladder is computed as a projection for the question. This does not establish universal tensor support or a compression ratio.

Documented implementation, with carrier/reopen and algebra gates reported in the September 14 engineering ledger. SDK, customer-release and platform qualification must be checked for the deployment you select.

Compare the semantics

your application needs.

Time-series specialists and multimodel databases already solve valuable parts of this problem. The useful question is which meaning and operations you get together.

Timescale

SQL time buckets and gap handling

Timescale can leave gaps as NULL and offers optional interpolation or carrying values forward. 8DB’s case here is its typed observation and coverage model, rather than merely the ability to avoid filling a gap.

Read Timescale’s documentation

(https://docs.timescale.com/api/latest/hyperfunctions/gapfilling/time_bucket_gapfill/)

QuestDB

Late data and temporal joins

QuestDB accepts out-of-order data on its documented ingestion paths and supports ASOF JOIN. Compare those capabilities with the versioned history and observation semantics your application requires; a temporal join and a historical database view answer different questions.

Late-data handling

(https://questdb.com/docs/concepts/out-of-order-data/)

·

ASOF JOIN

(https://questdb.com/docs/query/sql/asof-join/)

SurrealDB

Time series in a broader model

SurrealDB documents time-series records, aggregation and time buckets. For a mixed-data application, compare the operations and composition paths you need, including how uncertainty, source context and late changes travel through them.

Read SurrealDB’s documentation

(https://surrealdb.com/docs/learn/data-models/time-series/overview)

The potential advantage is less application logic to assemble around these semantics. These selected comparisons do not establish that competitors cannot represent the same information with schemas, extensions or custom code.

Performance / Recorded bulk-loading configuration

Five million readings.

Queryable in 2.56 seconds.

QuestDB took 5.16 seconds in the same recorded M1 campaign, approximately twice the wait.

The tested 8DB bulk path received and parsed the input, sorted it and built flat leaves and an index. The timer ended when the data could be queried.

Historical configuration comparison:

Apple M1, 16GB; five million readings with 50 million metric values; three rounds. 8DB used four HTTP writers; QuestDB used one TCP stream. Both used buffered loading without power-loss-safe completion during the load.

This specialized bulk path is separate from the newer typed durable carrier described above. Its result does not measure the performance of that carrier, its protection profile, energy use or every modality.

Read the comparison and methods

(https://8braid.com/journal/8db-questdb-tsbs-time-to-queryable)

Seconds until queryable / lower is better

8DB

2.56 s

QuestDB

5.16 s

Median of three historical rounds.

Different client configurations; buffered completion.

Published evidence and full conditions

(https://8braid.com/journal/8db-questdb-tsbs-time-to-queryable)

Input → usable value / interactive design example

Turn a late sensor report into a reviewable maintenance decision

0

1

Receive a reading

→

0

2

Preserve its meaning

→

0

3

Analyze the window

→

0

4

Connect the asset

→

0

5

Review the decision

→

[Diagram: time series representation: conceptual diagram]

Step

1

/

Time series

Receive a timestamped observation with units and detection context

Measured points, an interval bound and a visible gap retain different meanings along the same timeline.

Next: Preserve its meaning

Conceptual application workflow. Qualify the supported operations, external tools, protection and persistence for the complete path. These diagrams are explanatory, not measured results.

Read the complete workflow and comparison scope

Receive a timestamped observation with units and detection context

Store the typed sample under the selected late-data policy

Read the relevant version and derive a qualified rollup or rank braid

Relate the finding to the asset, inspection history and source report

Return a reviewable decision view with freshness and evidence

The time-series, rollup and rank-braid paths are documented. The asset-to-report workflow shown here is an application design example. Its value is measured at the complete decision view, including source assembly and required protection.

Keep the signal connected

to the rest of the question.

A reading often matters because of its location, its relationship to equipment or the history around it. Time series are one native modality in 8DB’s broader engine.

Existing connections

Documented paths connect persisted series to similarity search, interval rollups, rank braids and multiscale layers. A molecular-dynamics projection also uses observations read through the carrier.

Those are specific integration paths. Their existence does not qualify every possible mixed-model query.

What this can open up

A monitoring application could relate a sensor change to a place, a device graph and similar past events with fewer data handoffs. The practical benefit depends on the operations, deployment and guarantees the application needs.

Explore the other native models

(https://8braid.com/modalities)

Related articles

Take the next step into the thinking.

Benchmark & methods

Half the wait: 8DB vs. QuestDB on an M1 laptop

(https://8braid.com/journal/8db-questdb-tsbs-time-to-queryable)

Explore the measured path, comparison and conditions.

Mechanism & application

Before a Fleet Trusts the Model, It Has to Trust the Data Under It

(https://8braid.com/journal/the-data-layer-under-predictive-sustainment)

Explore the ideas and implementation context behind this capability.

Mechanism & application

8DB | Native Multimodal Data: Connect the Dots Across Graphs, Maps and Time Series

(https://8braid.com/journal/modality-is-a-projection)

Explore the ideas and implementation context behind this capability.

Technical reference

Enough detail to make a decision.

Current implementation and verification scope

This reference summarizes the time-series carrier and algebra documented as merged and internally deployed by September 14, 2026. Engineering records report persistence/reopen checks for the carrier, rollups and rank braids, and deployed-route checks for the related operations. This page review did not rerun those tests or certify every platform.

The trained multiscale path uses per-series/window projections and explicit staleness. Retention-expired state and stronger outage classification remain separate work in the inspected records. An unknown cause of missingness must remain unknown.

Does a gap tell me why a sensor failed?

Only as far as the evidence supports. Cadence and deployment windows establish whether a reading was expected. The inspected implementation does not always distinguish an instrument outage from data that was never ingested; both can remain missing-source with unknown cause.

Can I reproduce the exact earlier view?

An as-of transaction version selects the base observations and admitted deltas available to that version. Specify the version and late-data policy. A latest read reaching the tail can be marked unsettled; it should not be presented as a final historical account.

How do encryption and device support apply?

Check the protected operation-by-modality matrix and the supported build for your device and data path. A native data model does not by itself prove that every query, sync route or platform has been qualified under every cryptographic profile.

Explore 8DB’s post-quantum architecture

(https://8braid.com/pqc)

.

Which performance measurements should we use?

Separate bulk time-to-queryable from durable typed ingestion, query latency, storage footprint and recovery. For an evaluation, match workload, data size, clients, hardware, accuracy, protection and acknowledgement boundary, then record any deferred work. Energy needs measured joules per completed job; storage endurance needs write accounting.

The linked historical article retains its original conditions. A benchmark for the newer typed carrier remains a distinct evidence requirement.

Read, cite or share

This page is designed to stand on its own. Definitions, conditions and sources remain in the readable text.

Download this reference

(https://8braid.com/modality-reference/time-series.md)

Public reading

8DB modality overview and implementation boundaries

(https://8braid.com/modalities)

8DB versus QuestDB: historical M1 loading comparison

(https://8braid.com/journal/8db-questdb-tsbs-time-to-queryable)

Benchmarks and broader comparison context

(https://8braid.com/benchmarks)

Reference review: 17 September 2026. Implementation status source: September 14 ledger. Benchmark: September 8 historical campaign, article updated September 17. Detailed provenance and release tasks are retained in the private editorial record.

Bring the question

your data must answer.

Describe the observations, devices and guarantees your application needs. Start an evaluation around that work.

Discuss a time-series workload

(https://8braid.com/build)

Include data scale, late-data behavior and the required durability and protection.

