ClickHouse 26.10: 6 Proven Ways It Reads Less Data

ClickHouse 26.10 shipped on 22 October 2026 with 104 new features and 225 performance optimizations, and most of the ones that matter for real-time analytics do the same thing: they stop the engine from reading, decoding or holding data the query never needed. We ran six of them against a 40-million-row clickstream table. The short version: a “first 15 time buckets” query went from 40.0 million rows read to about 0.13 million, a join on a shared sort key got faster and stopped needing a hash table, and an IN subquery ran in 51 MiB where it previously needed 183 MiB.

Not everything in ClickHouse 26.10 landed that cleanly. The same Top-K query in descending order only halved its read, the now() support in the query condition cache is behind an experimental switch in the build we tested, and one default-on optimization made a query slightly slower on our two-core box. Those results are in here too, with the settings that produced them.

As of 20 November 2026. ClickHouse 26.10 is the current monthly stable release (26.10.2.103); 26.8 is the current LTS. Our earlier write-up of that line is here: ClickHouse 26.8 LTS for real-time analytics. Upstream sources for this post are the ClickHouse 26.10 changelog and the 26.10 release call slides.

ClickHouse 26.10 for real-time analytics: the scorecard

Each row is one ClickHouse 26.10 change, how it is switched, and what we saw. “Default” is what system.settings reported on our build; check yours with the inventory query near the end, because defaults can move between a monthly release and its patch versions.

Change in ClickHouse 26.10Setting and defaultWhat we measuredVerdict
Top-K dynamic filtering for GROUP BYenable_group_by_top_k_dynamic_filtering = 1Ascending: 241 ms to 7 ms, 40.0M to 0.13M rows. Descending: 427 ms to 289 msAdopt. Mind the sort direction
Query condition cache for time conditionsuse_query_condition_cache_for_time_conditions = 0 (Experimental tier)today() - 1: 40.0M to 9.53M rows on repeat. Sliding now(): no hits inside the first grid cellTest only
Merge join sharded by primary key rangesquery_plan_join_shard_by_pk_ranges = 1709 ms to 485 ms; fits in 9 MiB against 359 MiB for a hash joinAdopt where both sides share a sort key
IN subqueries spill to diskmax_bytes_before_external_set = 0, ratio 0.5Fits in 51 MiB instead of 183 MiB, at 5.3 times the elapsed timeSafety net, not a speedup
Columns cacheuse_columns_cache = 0 (Experimental tier)39 ms to 31 ms on a small hot set; zero hits when the column outgrew the cacheTest only
String filtering during the scanapply_string_filters_during_scan = 1Bytes materialised: 1,970 MB to 397 MB. Elapsed time: no betterLeave on, expect memory relief

ClickHouse 26.10 lab results chart showing the share of data read with each performance feature enabled

Figure 1. ClickHouse 26.10 features compared by how much data the engine still reads once each one is enabled. Bars are our lab medians, not vendor figures.

How we measured ClickHouse 26.10

The numbers come from one small machine on purpose: 2 vCPU, 7 GiB RAM, local disk, Linux x86_64. A box this size cannot flatter anything that depends on wide parallelism, which makes the row-count and memory results easier to trust. The engine was the embedded build shipped as chDB 4.5.1, which reports version 26.11.1.1: a build cut after 26.10, so it carries the 26.10 changes. Treat default values here as “our build” and confirm them on your own 26.10 server.

Every timing is the median of five runs with the spread in brackets, query cache off, data fully merged and in the page cache. Rows and bytes read come from the query statistics, skip counts from system.events deltas. For memory we report the smallest max_memory_usage at which the query completes, found by bisection, because the embedded build has no system.query_log.

CREATE TABLE rt.events
(
    event_time   DateTime,
    tenant_id    UInt32,
    user_id      UInt64,
    session_id   UInt64,
    event_type   LowCardinality(String),
    country      LowCardinality(String),
    device       LowCardinality(String),
    browser      LowCardinality(String),
    url          String,
    latency_ms   UInt32,
    revenue      Decimal(12, 2)
)
ENGINE = MergeTree
PARTITION BY toYYYYMMDD(event_time)
ORDER BY (tenant_id, event_time)
SETTINGS index_granularity = 8192,
         min_bytes_for_wide_part = 0,
         min_rows_for_wide_part = 0;

-- 40M synthetic events spread evenly over seven days, 500 tenants
INSERT INTO rt.events
SELECT
    toDateTime('2026-11-20 16:00:00') - toIntervalSecond(intDiv(number * 7 * 86400, 40000000)),
    cityHash64(number, 1) % 500,
    cityHash64(number, 2) % 4000000,
    cityHash64(number, 3) % 12000000,
    ['page_view','page_view','page_view','click','click','add_to_cart','search','purchase'][cityHash64(number, 4) % 8 + 1],
    ['US','IN','DE','GB','BR','JP','FR','SG','AU','CA','NL','ES'][cityHash64(number, 5) % 12 + 1],
    ['mobile','mobile','desktop','tablet'][cityHash64(number, 6) % 4 + 1],
    ['chrome','safari','firefox','edge','samsung'][cityHash64(number, 7) % 5 + 1],
    concat('https://shop.example.com/',
           ['home','search','product','cart','checkout','account','help'][cityHash64(number, 8) % 7 + 1],
           '/', toString(cityHash64(number, 9) % 250000), '?ref=', hex(cityHash64(number, 10) % 65536)),
    toUInt32(20 + cityHash64(number, 11) % 180 + if(cityHash64(number, 12) % 100 = 0, 2000, 0)),
    if(cityHash64(number, 4) % 8 = 7, toDecimal64(5 + cityHash64(number, 13) % 29500 / 100, 2), toDecimal64(0, 2))
FROM numbers(40000000);

OPTIMIZE TABLE rt.events FINAL;

-- A cross-tenant timeline copy, the shape most "what is happening now" panels read
CREATE TABLE rt.events_timeline
(
    event_minute DateTime,
    event_time   DateTime,
    tenant_id    UInt32,
    event_type   LowCardinality(String),
    latency_ms   UInt32,
    revenue      Decimal(12, 2)
)
ENGINE = MergeTree
ORDER BY (event_minute, tenant_id)
SETTINGS index_granularity = 8192,
         min_bytes_for_wide_part = 0,
         min_rows_for_wide_part = 0;

INSERT INTO rt.events_timeline
SELECT toStartOfMinute(event_time), event_time, tenant_id, event_type, latency_ms, revenue
FROM rt.events;

OPTIMIZE TABLE rt.events_timeline FINAL;

rt.events landed as 8 parts, 1.39 GiB on disk and 3.51 GiB uncompressed. rt.events_timeline is a single part of 4,883 granules. The OPTIMIZE ... FINAL statements are lab hygiene to get a stable part layout; do not copy them into a production runbook.

Top-K dynamic filtering in ClickHouse 26.10: GROUP BY that stops at the limit

The panel every operations dashboard has is “the last N time buckets”: group by a time bucket, order by it, keep a handful. Until now ClickHouse aggregated every bucket in the table and threw away all but N at the end, unless you remembered to add a time predicate. In ClickHouse 26.10 the aggregation step keeps a small heap of the best keys seen so far and publishes the worst of them back to the reader as a filter. Granules whose key range cannot beat that boundary are never read.

Diagram of Top-K dynamic filtering for GROUP BY in ClickHouse 26.10 showing granules skipped for ascending and descending order

Figure 2. Top-K dynamic filtering in ClickHouse 26.10. The aggregation heap feeds a boundary back into the MergeTree reader, which skips granules by primary key.

SELECT
    event_minute,
    count()                    AS events,
    sum(revenue)               AS revenue,
    quantile(0.99)(latency_ms) AS p99_ms
FROM rt.events_timeline
GROUP BY event_minute
ORDER BY event_minute ASC
LIMIT 15
SETTINGS enable_group_by_top_k_dynamic_filtering = 1;   -- 0 for the baseline

The plan shows the mechanism directly. Note the Top-K line on the aggregation step and the synthetic prewhere column on the read:

Limit (preliminary LIMIT)
└──Sorting (Sorting for ORDER BY)
   │  Sort description: event_minute ASC
   │  Limit 15
   └──Aggregating
      │  Keys: event_minute
      │  Aggregates: count(), sum(revenue), quantile(0.99)(latency_ms)
      │  Top-K: limit=15, columns=1, directions=[1]
      └──ReadFromMergeTree (rt.events_timeline)
            Parts: 1 | Granules: 4883
            Prewhere filter column:  __topKFilter(event_minute)
...  (five lines trimmed: limit/offset, skip merging, read type, output columns)
VariantMedian ms (range)Rows readTopKGranulesSkippedByPrimaryKey
ASC, filter off241 (210 to 276)40,000,0000
ASC, filter on7 (7 to 8)122,880 to 131,0724,867 to 4,868
DESC, filter off427 (410 to 597)40,000,0000
DESC, filter on, 2 threads289 (276 to 362)19.4M to 19.9M2,450 to 2,513
DESC, filter on, max_threads = 11,139 (1,068 to 1,356)40,000,0000

Top-K GROUP BY on the ClickHouse 26.10 lab build: rt.events_timeline, 40M rows, 15 buckets, five runs per variant.

The descending case is the one dashboards actually run

Ascending order is the easy direction: the reader starts at the front of the key, the heap fills with the smallest minutes at once, and almost everything after that is skipped. “Latest 15 minutes” is the opposite. The reader still walks the part front to back, so the boundary only becomes useful when a second thread happens to start in the newer half. With two threads that skipped about half the granules. With one thread it skipped none.

Two fixes worked in our lab. The first is the old one and still the right default: bound the scan with a time predicate so the primary key prunes before aggregation starts. The second is a descending sort key, which lets ClickHouse 26.10 read the newest data first:

CREATE TABLE rt.events_timeline_desc
(
    event_minute DateTime,
    event_time   DateTime,
    tenant_id    UInt32,
    event_type   LowCardinality(String),
    latency_ms   UInt32,
    revenue      Decimal(12, 2)
)
ENGINE = MergeTree
ORDER BY (event_minute DESC, tenant_id)
SETTINGS index_granularity = 8192,
         min_bytes_for_wide_part = 0,
         min_rows_for_wide_part = 0,
         allow_experimental_reverse_key = 1;

On that table the descending query fell from 208 ms (186 to 245) to 20 ms (19 to 27), and bytes read fell from 640 MB to 161 MB. The granule-skip counter stayed at zero, so the saving came from the prewhere filter discarding rows before the other columns were read, not from index pruning. Descending keys are still gated by an experimental MergeTree setting, so we would prototype with them and ship the time predicate.

Rolling windows in ClickHouse 26.10: the query condition cache meets now()

The query condition cache remembers, per part and per filter, which granules contained no matching rows. It has always had a blind spot for real-time analytics: a filter such as event_time >= now() - INTERVAL 12 HOUR is a different condition every second, so nothing could be reused. ClickHouse 26.10 addresses this by rounding the time constant onto a grid whose step follows the look-back distance. Writes round the bound up, reads round it down, and that asymmetry keeps a cached “nothing here” answer correct.

Diagram of the query condition cache time grid in ClickHouse 26.10 showing how a now() bound is rounded for cache reads and writes

Figure 3. How ClickHouse 26.10 rounds a now() bound onto a time grid so the query condition cache can serve rolling-window filters.

We filtered the timeline table on event_time, which is deliberately not in its sort key, so the primary index cannot help and every skipped granule is the cache at work.

SELECT
    tenant_id,
    count()                    AS events,
    quantile(0.99)(latency_ms) AS p99_ms
FROM rt.events_timeline
WHERE event_time >= today() - 1
GROUP BY tenant_id
ORDER BY p99_ms DESC
LIMIT 20
SETTINGS use_query_condition_cache = 1,
         use_query_condition_cache_for_time_conditions = 1;
Filter boundTime-condition switchFirst runRepeat runs
toDateTime('2026-11-20 10:00:00')not needed40.0M rows, 95 ms1.45M rows, 28 to 31 ms
today() - 1040.0M rows, 216 ms median40.0M rows, no cache hits
today() - 1140.0M rows, 225 ms9.53M rows, 146 to 170 ms
now() - INTERVAL 12 HOUR140.0M rows, 114 ms median40.0M rows, no hits, including after a 75 s wait

Query condition cache behaviour on the ClickHouse 26.10 lab build, cache dropped before each series.

Three things to take from this. First, on our build the switch reports default = 0 and tier = Experimental, so a stock configuration behaves exactly as before; the feature is something you opt into per query or per profile. Second, grid-aligned bounds such as today() - N or toStartOfDay(now()) hit on the next run and stay valid for the rest of the cell. Third, an unaligned sliding bound writes entries that only become readable in the following grid cell. For a 12-hour look-back that is up to 12 hours away, which we did not wait for.

For dashboard authors the practical move does not need the new switch at all: where the panel tolerates it, align the lower bound to the bucket (toStartOfHour(now()) - INTERVAL 24 HOUR, or a literal the application computes once a minute). A deterministic bound has been cacheable since the condition cache arrived, and in our run it cut the repeat read by 96 percent.

Enrichment joins on a shared sort key in ClickHouse 26.10

Real-time pipelines join fact streams to slowly changing sets all the time: sessions to attribution, orders to accounts, devices to firmware. When both tables are sorted by the join key, a merge join needs no hash table at all. The catch was that it ran on one stream. ClickHouse 26.10 splits both sides into matching primary-key ranges and runs an independent merge join per range, on by default.

Diagram of a merge join sharded by primary key ranges in ClickHouse 26.10 with lab timings against a hash join

Figure 4. A ClickHouse 26.10 merge join sharded by primary key ranges: each thread joins one pre-sorted slice of both tables.

-- 11,573,369 sessions joined to 8,999,013 attribution rows; both tables ORDER BY session_id
SELECT
    a.channel,
    count()        AS sessions,
    sum(s.revenue) AS revenue
FROM rt.sessions AS s
INNER JOIN rt.session_attribution AS a
    ON s.session_id = a.session_id
GROUP BY a.channel
ORDER BY revenue DESC
SETTINGS join_algorithm = 'full_sorting_merge',
         query_plan_join_shard_by_pk_ranges = 1;   -- 0 for the unsharded baseline
Join strategyMedian ms (range)Smallest max_memory_usage that completes
Merge join, sharding off709 (679 to 746)79 MiB
Merge join, sharding on485 (448 to 537)9 MiB
Hash join858 (775 to 875)359 MiB

Join strategies on the ClickHouse 26.10 lab build, 2 threads, five runs each.

On two threads the gain is 32 percent, which is roughly what two lanes can give. The ClickHouse 26.10 release call reports a far larger gain on a wide server for a 200M by 50M row join, and the mechanism supports that: lanes scale with cores. What interested us more is the memory column. A join that fits in single-digit MiB cannot be the query that takes the node down at peak, and you get it without touching the default join_algorithm for everything else. Set the algorithm per query on the joins whose tables you have deliberately co-sorted.

Funnel filters: ClickHouse 26.10 IN subqueries that spill instead of failing

“Purchases from sessions that added to cart” is a set-membership query, and the set is built in memory. With enough sessions it is the query that trips MEMORY_LIMIT_EXCEEDED on a shared cluster. ClickHouse 26.10 lets the set spill to disk once it crosses a threshold.

SELECT
    country,
    count()      AS purchases,
    sum(revenue) AS revenue
FROM rt.events
WHERE event_type = 'purchase'
  AND session_id IN
      (
          SELECT session_id
          FROM rt.events
          WHERE event_type = 'add_to_cart'       -- 4,090,534 distinct sessions
      )
GROUP BY country
ORDER BY revenue DESC
SETTINGS max_memory_usage = '128Mi',
         max_bytes_before_external_set = '32Mi';

Without the spill threshold and under the same 128 MiB cap, this is what came back:

Code: 241. DB::Exception: Query memory limit exceeded: would use 178.04 MiB
(attempt to allocate chunk of 126.01 MiB), maximum: 128.00 MiB:
While executing CreatingSetsTransform. (MEMORY_LIMIT_EXCEEDED)
ConfigurationMedian ms (range)Smallest limit that completesSpill events
Set in memory689 (661 to 719)183 MiBnone
max_bytes_before_external_set = '32Mi'3,678 (3,569 to 3,835)51 MiBSetsSpilledToDisk 1, ExternalSetWritePart 2, about 16.1 MB compressed

IN subquery set handling on the ClickHouse 26.10 lab build, five runs each.

That is a 72 percent cut in required memory for 5.3 times the latency. Read it as a guard rail: the query finishes instead of failing, and it is slow enough that you will notice and fix the data model. The changelog also describes a ratio-based trigger, max_bytes_ratio_before_external_set, at 0.5 by default. In a separate run with a tuple-keyed set and a 256 MiB cap, the default ratio alone did not save the query, so set the absolute threshold explicitly on the profiles where it matters.

Repeat reads in ClickHouse 26.10: the columns cache and string filtering during the scan

The ClickHouse 26.10 columns cache (experimental)

A dashboard that refreshes every few seconds decompresses and deserialises the same granules again and again. The page cache saves the disk read, not the decoding. The columns cache in ClickHouse 26.10 keeps decoded column ranges of wide parts in memory. It is experimental and off by default.

SELECT country, device, count() AS c, avg(latency_ms) AS l
FROM rt.events
WHERE event_time >= '2026-11-20 00:00:00'
GROUP BY country, device
SETTINGS use_columns_cache = 1;

Over 3.81 million rows the query took 39 ms (36 to 67) with the cache off. With it on, the first run took 59 ms while it recorded 1,864 misses, and the next five took 26 to 37 ms with 1,864 hits each. A LIKE scan of the whole url column, roughly 2 GB decoded, behaved very differently: 4,887 misses on every run and no hits. The server setting columns_cache_size had defaulted to 841 MB (columns_cache_size_to_ram_ratio = 0.1), and the column did not fit. Size the cache to the hot set you expect to serve, or it will churn.

String filtering during the scan

LIKE, startsWith, endsWith and position filters are evaluated in ClickHouse 26.10 while a string column is being deserialised, so non-matching values are never copied into a block. The switch is apply_string_filters_during_scan, on by default.

SELECT count()
FROM rt.events
WHERE url LIKE '%/checkout/%'                      -- 5,715,813 of 40,000,000 rows match
SETTINGS apply_string_filters_during_scan = 1;     -- 0 for the previous behaviour

Bytes read into query blocks dropped from 1,970 MB to 397 MB. Elapsed time did not improve: 657 ms (617 to 769) off against 925 ms (761 to 936) on in one session, and 610 to 727 ms against 685 to 833 ms in fresh processes. With 14 percent of rows matching on two cores, the per-value check costs about what the copy saved. We also could not isolate the peak-memory change, because the embedded process idles near 475 MiB and the difference sat inside that noise. Expect this one to pay on selective filters over long strings, such as log bodies, on memory-tight nodes.

What a two-core lab cannot show about ClickHouse 26.10

Three ClickHouse 26.10 changes target concurrency and large hash tables, and we are not going to pretend a small box measured them. The figures in this section are the upstream ones from the ClickHouse 26.10 release call, attributed as such.

Hash tables at a 0.9 load factor. Large hash tables move to Robin Hood hashing in place, lifting the maximum load factor from 0.5 to 0.9. Upstream reports a GROUP BY over 10 million keys dropping from 24.7 GB to 16.3 GB and a 100-million-value uniqExact from 13.5 GB to 4.6 GB. For user-level and session-level rollups, that is headroom you get without touching a schema.

Narrower pipelines under load. A busy server no longer gives every query one processing lane per core. Upstream measured ten concurrent clients on 96 cores and reported lower p99 memory and about 15 percent less CPU time per query. For a serving tier this matters more than any single-query number.

Query-aware workload schedulers. Workloads in ClickHouse 26.10 gain fair, las (short queries first) and priority schedulers alongside fifo, plus memory limits with a spill threshold. The statements below were accepted by our build and the workload was usable from a query; we have not load-tested the scheduling behaviour.

CREATE RESOURCE cpu (MASTER THREAD, WORKER THREAD);

CREATE OR REPLACE WORKLOAD all
SETTINGS scheduler = 'las';                 -- short queries first

CREATE OR REPLACE WORKLOAD dashboards IN all
SETTINGS weight = 9;

CREATE OR REPLACE WORKLOAD adhoc IN all
SETTINGS weight = 1,
         max_memory = '16Gi',
         max_memory_before_spill = '8Gi';

-- Verify, then route a query
SELECT name, parent, create_query FROM system.workloads ORDER BY name;

SELECT count() FROM rt.events SETTINGS workload = 'dashboards';

-- Rollback: DROP WORKLOAD adhoc; DROP WORKLOAD dashboards; DROP WORKLOAD all; DROP RESOURCE cpu;

Before you upgrade to ClickHouse 26.10

The ClickHouse 26.10 changelog lists 37 backward-incompatible changes. These are the ones we would check first on a real-time analytics cluster. Blast radius for all of them is the whole cluster once the first replica restarts on the new binary, and the rollback path is a binary downgrade, so rehearse on a restored copy.

ChangeWho is hitAction before the first node is upgraded
The pre-analyzer query path is removedMixed-version clusters during a rolling upgrade; anyone still running enable_analyzer = 0Set enable_analyzer = 1 on every server and soak it on the current version first
system.metric_log moves to a bucketed Map schemaExporters and dashboards that read metric columns from itTest collectors; add <schema_type>wide</schema_type> under <metric_log> to keep the old layout
External join thresholds act as hard caps for all hash joinsProfiles with max_bytes_before_external_join set lowReview the thresholds; legacy_join_size_limits_trigger_spilling = 1 restores the old behaviour
skip_unavailable_shards = 1 now errors when every shard is skippedDistributed reads that relied on an empty resultHandle ALL_CONNECTION_TRIES_FAILED in the application
Named collection overrides need an extra grantTables and dictionaries that override collection keysRecreate tables that override NOT OVERRIDABLE keys, or the server will not start
Non-compact Distributed queue format is removedClusters with use_compact_format_in_distributed_parts_names = 0Set it to 1 and let the queues drain
Seccomp filter is applied at startupSandboxed containers; executable UDFsSet seccomp to log or disabled where the syscall is refused
arrayCount returns UInt64Materialized views and inserts with strict target typesSet array_count_legacy_uint32_result = 1 during the rolling upgrade

Run this on the current version and again on a ClickHouse 26.10 test node, and diff the output. It is read-only. Our build returned the block below; note that enable_analyzer is already reported as Obsolete.

SELECT name, value, default, tier
FROM system.settings
WHERE name IN
(
    'enable_group_by_top_k_dynamic_filtering',
    'query_plan_join_shard_by_pk_ranges',
    'apply_string_filters_during_scan',
    'max_bytes_before_external_set',
    'max_bytes_ratio_before_external_set',
    'use_query_condition_cache',
    'use_query_condition_cache_for_time_conditions',
    'use_columns_cache',
    'enable_analyzer'
)
ORDER BY name;
┌─name──────────────────────────────────────────┬─value─┬─default─┬─tier─────────┐
│ apply_string_filters_during_scan              │ 1     │ 1       │ Production   │
│ enable_analyzer                               │ 1     │ 1       │ Obsolete     │
│ enable_group_by_top_k_dynamic_filtering       │ 1     │ 1       │ Production   │
│ max_bytes_before_external_set                 │ 0     │ 0       │ Production   │
│ max_bytes_ratio_before_external_set           │ 0.5   │ 0.5     │ Production   │
│ query_plan_join_shard_by_pk_ranges            │ 1     │ 1       │ Production   │
│ use_columns_cache                             │ 0     │ 0       │ Experimental │
│ use_query_condition_cache                     │ 1     │ 1       │ Production   │
│ use_query_condition_cache_for_time_conditions │ 0     │ 0       │ Experimental │
└───────────────────────────────────────────────┴───────┴─────────┴──────────────┘

Our stance on ClickHouse 26.10, November 2026

ClickHouse 26.10 is a monthly release, not an LTS. For fleets that upgrade twice a year, stay on 26.8 LTS and put 26.10 in a test environment now, because 26.9 and 26.10 between them remove the old analyzer path and you want that rehearsal done long before the next LTS forces it.

For teams already on the monthly train, we would move to ClickHouse 26.10 for three workloads: Top-K panels over a time-sorted key, joins between tables that share a sort key, and multi-tenant clusters where one oversized IN set can starve everyone else. We would keep the time-condition cache, the columns cache and descending sort keys out of production profiles until they leave the Experimental tier, and we would not change a default-on setting without a before-and-after from system.query_log on your own queries.

Everything above was measured on one small machine with synthetic data. Test on your own workload before applying any of it to production, and keep a restore you have actually exercised. If you want a second pair of eyes on a ClickHouse 26.10 upgrade plan or on the query patterns behind a slow dashboard, our ClickHouse consulting and 24×7 ClickHouse support teams do this work every week.

About ChistaDATA Inc. 273 Articles
ChistaDATA is a full-stack ClickHouse infrastructure operations company delivering consulting, 24×7 enterprise support, and managed services, with core expertise in performance engineering, scalability, and data SRE. Headquartered in California, our consulting and support engineering teams operate from San Francisco, Vancouver, London, Germany, Russia, Ukraine, Australia, Singapore, and India, providing follow-the-sun, enterprise-class consultative support around the clock. We work closely with more than 200 customers globally, including some of the largest planet-scale internet properties, financial-services institutions, consumer brands, and industrial IoT programmes.