Free audit

View Audit Scope
Cardinality & Storage OptimizationTSI1 Cardinality · WAL & TSM Tuning · IOx Parquet · Flux to InfluxQL/SQL

InfluxDB Performance Tuning & Cardinality Optimization

JusDB tunes InfluxDB 1.x, 2.x, Enterprise, and InfluxDB 3.0 (IOx) deployments to eliminate OOM restarts, WAL cache write rejections, and multi-second dashboard queries. Our engineers cut runaway TSI series cardinality, calibrate TSM snapshot and compaction throughput on NVMe storage, optimize InfluxDB 3.0 Apache Arrow DataFusion and Parquet partition pruning, and refactor unpushed Flux scripts into fast InfluxQL and SQL.

The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance.

  • NDA before access
  • Read-only by default
  • Written tuning scope & rollback safety

InfluxDB performance & memory levers

Select an optimization lever

Series File & TSI1 Partition Compaction

RAM & mmap bound

Every active series in InfluxDB 1.x/2.x lives in the `_series` directory and 8-partition TSI1 index files; keeping active series under 1-2M per node prevents mmap thrashing.

We use `influx_inspect reporttsi` and `buildtsi` alongside Telegraf tag-to-field conversion to cut `_series` memory footprint by 70-90%.

Inspect tuning progression simulator

TSM/TSI parameters and IOx partition pruning verified against InfluxData Storage & Query Tuning documentation.

Storage engines tuned
TSM + TSI1 (InfluxDB 1.x / 2.x / Enterprise) and IOx Apache Arrow + Parquet (InfluxDB 3.0)
Query & ingest focus
Cardinality reduction, WAL cache sizing, Flux pushdown / InfluxQL, and Telegraf 10k gzip batching
Initial-response targets
15 minutes for a critical (P1) incident under a 24x7 support agreement; 2 to 4 hours in business hours. See details
Coverage hours
Business hours (03:30–12:30 UTC) by default; 24x7 on-call available under your service agreement

Selected clients

  • Innoviti
  • Blitz
  • Freecharge
  • Nango
  • Recochain
  • Screen Facts
  • Nexora
  • WeCredit

Storage & query bottlenecks

InfluxDB signals behind WAL write stalls, OOMs, and slow dashboards

We correlate `_internal` WAL/TSM compaction counters, `reporttsi` series counts, and Flux profiler operator timings to fix root causes rather than masking them with larger VMs.

InfluxDB performance symptoms, root causes, and tuning remediations
InfluxDB metric / errorWhat is usually happeningWhere we start
cache-max-memory-sizeTelegraf agents receive HTTP 500 timeout: cache-max-memory-size exceededTSM snapshot compactions cannot flush the in-memory WAL cache fast enough due to slow disk IOPS, tiny unbatched writes, or excessive TSI series count.Raise `storage-cache-max-memory-size` (e.g., 4-8 GiB), tune `storage-cache-snapshot-memory-size` (100 MiB), isolate `wal-dir` on NVMe, and batch Telegraf writes to 10,000 points.
TSI Index Thrashinginfluxd RSS memory climbs until Linux OOM-killer terminates the processMillions of orphaned or ephemeral tag combinations bloat the `_series` file and TSI1 `.tsi`/`.tsl` index partitions, exceeding host RAM during index merges.Profile tag keys with `influx_inspect reporttsi`, convert dynamic tags to fields in Telegraf, drop expired retention shards, and tune `storage-series-id-set-cache-size`.
Flux Query OOM / 30s+Grafana panels time out and spike Go heap allocation on 7-day+ rangesFlux queries call `filter(fn: (r) => r._value > x)`, `pivot()`, or `join()` before windowing, breaking storage pushdown and pulling raw TSM points into RAM.Reorder Flux stages so `range()`, tag `filter()`, and `aggregateWindow()` execute inside the storage engine, or switch Grafana data sources to native InfluxQL / FlightSQL.
TSM Level 4 CompactionSustained peak disk utilization and p99 read latency spikes every afternoonFull and level-4 TSM compactions rewrite multi-gigabyte shard files that are still receiving late-arriving writes, competing with live WAL flushes.Increase `storage-compact-full-write-cold-duration` (e.g., `4h` to `12h`), cap `storage-compact-throughput-burst` to 60% of disk bandwidth, and right-size shard group duration.
Slow 90-Day DashboardsLong-range executive dashboards scan hundreds of millions of raw 10s pointsDashboards query the raw high-resolution bucket across months instead of reading pre-aggregated 5m or 1h roll-up series.Create tiered downsampling tasks/Continuous Queries writing `min`, `max`, `mean`, and `count` into a 1-year retention bucket and route long-range Grafana panels to it.
IOx Unpruned ParquetInfluxDB 3.0 queries scan thousands of S3 Parquet files for a single deviceThe InfluxDB 3.0 table uses only the default daily time partition without partitioning or sorting by the primary `tenant_id` or `device_tier` tag.Define custom IOx partition templates combining time granularity with your highest-selectivity filter tag so DataFusion prunes non-matching Parquet partitions.

Optimization workstreams

What our InfluxDB performance tuning engagement covers

We tune every layer of the stack: Telegraf edge batching, TSI1 series cardinality, WAL and TSM compaction, Flux/InfluxQL/SQL execution, and v3 IOx Parquet pruning.

  • TSI1 series cardinality & _series cache tuning

    We shrink bloated `_series` files and TSI1 index partitions so active time-series metadata stays resident in RAM without OOM kills.

    • Pinpoint high-cardinality measurements and tags with influx_inspect reporttsi
    • Tune storage-series-id-set-cache-size and storage-max-index-log-file-size

    influx_inspect reporttsi · TSI1 · storage-series-id-set-cache-size

  • WAL cache, TSM snapshot & compaction calibration

    Stop `cache-max-memory-size exceeded` errors and smooth out disk I/O by aligning WAL and TSM compaction settings with your NVMe/EBS hardware.

    • Separate wal-dir and data dir across dedicated NVMe or provisioned-IOPS volumes
    • Calibrate cache-snapshot-memory-size, cold duration, and compaction burst MB/s

    cache-max-memory-size · cache-snapshot-memory-size · compact-throughput-burst

    InfluxDB consulting
  • Flux pushdown refactoring & InfluxQL/SQL rewrites

    Cut dashboard query times from 20+ seconds to under 100ms by eliminating Go heap materialization in Flux or switching to InfluxQL/SQL.

    • Verify storage pushdown execution plans using Flux profiler (`profiler/operator`)
    • Rewrite heavy Flux dashboards into native InfluxQL or InfluxDB 3.0 DataFusion SQL

    import "profiler" · aggregateWindow · InfluxQL · Apache Arrow FlightSQL

  • Downsampling roll-ups & shard group alignment

    Keep raw sub-minute metrics in short-lived shards while serving 30-day to 2-year queries from pre-aggregated roll-up buckets.

    • Match shard group durations (1h, 1d, 7d) to retention policies for instant unlink
    • Stagger downsampling task schedules (`offset`) to avoid top-of-the-hour CPU spikes

    ALTER RETENTION POLICY · SHARD DURATION · Continuous Queries / v2 Tasks

  • Telegraf batching, compression & edge aggregation

    Reduce HTTP write request overhead on `influxd` by 10x through proper Telegraf batching, gzip compression, and edge pre-aggregation.

    • Tune metric_batch_size (5,000-10,000), flush_jitter, and content_encoding = gzip
    • Deploy Telegraf basicstats/minmax aggregators and tag-to-field converters

    metric_batch_size · flush_jitter · content_encoding=gzip · processors.converter

  • InfluxDB 3.0 IOx Parquet & DataFusion optimization

    Maximize query speed on InfluxDB 3.0 (Cloud Dedicated, Clustered, Core) with custom Parquet partition templates and Arrow memory tuning.

    • Design tag + time partition templates for high-selectivity Parquet pruning
    • Tune IOx ingester buffer thresholds, compactor file sizes, and Querier caches

    InfluxDB 3.0 IOx · Parquet partition templates · Apache DataFusion · FlightSQL

    InfluxDB migration services

Before vs after tuning & response targets

How JusDB InfluxDB tuning compares with default configurations

Instead of vertically scaling RAM to hold millions of ephemeral series, we bound cardinality, calibrate WAL/TSM flushing, and push aggregations into the storage engine.

Comparison between uncalibrated InfluxDB setups and JusDB performance tuning
Performance layerUncalibrated InfluxDB setupAfter JusDB performance tuning
Series cardinality & TSI memoryLeaves `inmem` or default TSI settings untouched while unbounded tags push series count past 10 million.Enforces `tsi1`, demotes high-cardinality tags to fields in Telegraf, and tunes `series-id-set-cache-size`.
WAL & TSM write stabilityDefault 1 GiB `cache-max-memory-size` and 25 MiB snapshots stall under high-throughput Line Protocol bursts.Scales WAL cache to 4-8 GiB, isolates `wal-dir` on NVMe, and tunes compaction throughput caps.
Dashboard query executionSlow Flux queries pull millions of points into Go memory with `pivot()` and unpushed filters.Refactors Flux for storage pushdown or rewrites panels to native InfluxQL and FlightSQL.
Long-range historical queriesScans raw 10-second telemetry across 90+ days on every Grafana dashboard refresh.Builds staggered 5m and 1h downsampled buckets and routes Grafana via dynamic time-range variables.
Telegraf ingestion efficiencyHundreds of agents send unbatched 1,000-point uncompressed payloads at the exact same second.Configures 10,000-point gzip-compressed batches with randomized `flush_jitter` to flatten CPU spikes.
Shard expiration & deletesRuns `DELETE WHERE time < ...` statements that trigger days of TSM tombstone compaction I/O.Aligns shard durations with bucket retention so expired data drops via zero-I/O directory unlinks.

Published initial-response targets by severity

Standard business hours: 03:30–12:30 UTC

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

SeverityInitial responseDefinitionChannel & coverage
P1 · Critical15 minutesProduction database down, primary unreachable, data corruption risk, or active failover event.24x7 on-call (under your service agreement) · Direct PagerDuty, Opsgenie, or phone page plus incident bridge
P2 · High30 minutesSevere latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.24x7 on-call (under your service agreement) · On-call alert plus shared Slack or Teams channel
P3 · Medium60 minutesNon-critical slow query regression, staging issue, backup warning, or replication check alert.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket
P4 · Low90 minutesConfiguration question, index advisory, planned schema review, or general operational request.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

Our engineering team is in India; business-hours coverage is Mon–Fri 09:00–18:00 IST (UTC+5:30), and 24x7 on-call is available under your service agreement.

Initial-response targets, not resolution guarantees. The target for your engagement is set in your service agreement.

Interactive tuning progression

How cardinality pruning, WAL tuning, and pushdown accelerate InfluxDB

Step from a cardinality-bloated TSM stall to sanitized Telegraf batching and NVMe WAL tuning, and finally to storage-pushed InfluxQL/SQL with tiered downsampling.

InfluxDB ingestion & query optimization simulator

Select a tuning stage to inspect WAL cache state, TSI series count, and Grafana p99 query latency.

Telegraf Collectors, TSM/TSI Engine & Grafana Queries

800 Telegraf agents flush unbatched 1k payloads with `container_id` tags every 10s; TSM compactions saturate EBS IOPS while Flux `pivot()` queries exhaust Go heap.

p99 Query: 14.2s · 12M series · HTTP 500 WAL cache stalls
  • TSM WAL & Snapshot Engine

    1 GiB cache-max-memory-size · Shared EBS gp2 volume

    STALLED · cache-max-memory-size exceeded (HTTP 500)

  • TSI1 Index (_series = 12.4M)

    Unbounded container_id & pod_uid tags

    THRASHING · 48 GiB RSS memory · High page faults

  • Flux Query Runtime

    Scanning 30d raw bucket without storage pushdown

    TIMEOUT · 14.2s p99 · Go GC pause spikes

When high-cardinality tags bloat the TSI index and hundreds of agents send synchronized unbatched writes to a default 1 GiB WAL cache, TSM snapshot compactions fall behind and queries time out.

Representative production deliverable

How a Flux-to-InfluxQL pushdown and TSM compaction tune is delivered

We provide side-by-side query rewrites, Flux profiler verification, and calibrated `config.toml` / `influxdb.conf` parameters.

Sample finding · Unpushed Flux pivot() OOM & TSM cold compaction stormInfluxDB 2.7 · 16 vCPU / 64 GiB NVMe instance

Finding

Unpushed Flux pivot() before aggregateWindow() allocated 22 GiB per Grafana refresh

Fleet telemetry dashboards called pivot() on raw 5-second points across 14 days before windowing, disabling TSM storage pushdown and pulling 38 million points into Go heap. Reordering the pipeline (and moving key panels to InfluxQL plus a 5m downsampled bucket) cut query time from 14.2s to 42ms.

14-day Dashboard p9914,200ms → 42ms
Per-query Go heap alloc22 GiB → 38 MiB

1. Pushdown-safe Flux refactor & equivalent native InfluxQL query

flux pushdown vs native influxql

// Pushdown-safe Flux: filter tags + aggregateWindow() BEFORE pivot()
from(bucket: "telemetry_5m_rollup")
  |> range(start: -14d)
  |> filter(fn: (r) => r._measurement == "inverter_metrics" and r.site_id == "us-west-04")
  |> filter(fn: (r) => r._field == "kw_out" or r._field == "temp_c")
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false)
  |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")

-- Equivalent Native InfluxQL (executes directly on TSM/IOx iterators):
SELECT MEAN("kw_out") AS "kw_out", MEAN("temp_c") AS "temp_c"
FROM "telemetry_5m_rollup"."autogen"."inverter_metrics"
WHERE time >= now() - 14d AND "site_id" = 'us-west-04'
GROUP BY time(1h), "inverter_id" FILL(none)

2. InfluxDB 2.x config.toml: Memory, WAL, and query concurrency guardrails

/etc/influxdb/config.toml · production tuning

storage-cache-max-memory-size = 6442450944        # 6 GiB WAL cache ceiling
storage-cache-snapshot-memory-size = 104857600    # 100 MiB TSM snapshot flush
storage-compact-full-write-cold-duration = "8h"   # Wait 8h before full L4 compaction
storage-compact-throughput = 134217728            # 128 MiB/s sustained compaction
storage-compact-throughput-burst = 201326592      # 192 MiB/s burst compaction
storage-series-id-set-cache-size = 500            # Cache hot tag filter bitmaps
query-concurrency = 32
query-max-memory-bytes = 8589934592               # 8 GiB cap across active queries

Ways to work together

How to engage JusDB for InfluxDB performance tuning

Start with a free read-only cardinality and query audit, commission a focused tuning sprint, or retain ongoing InfluxDB SRE coverage.

Scoped tuning sprintThis page

Stop OOMs, WAL stalls & slow queries.

A fixed-scope engagement delivering Telegraf tag sanitization, calibrated WAL/TSM settings, downsampling buckets, and Flux-to-InfluxQL/SQL rewrites.

Tuning deliverables agreed in writing

  • TSI cardinality remediation
  • WAL & TSM compaction tuning
  • Flux pushdown & InfluxQL/SQL
  • Downsampling & shard durations
  • InfluxDB 3.0 IOx Parquet pruning
Free InfluxDB latency audit

Cardinality, WAL & slow queries audited.

We inspect your `reporttsi` output, `config.toml` / `influxdb.conf`, Telegraf configs, and slow query logs, returning a prioritized tuning roadmap.

What we check in a read-only audit

  • TSI series cardinality per measurement & rogue tag keys
  • WAL cache saturation, TSM compaction & shard durations
  • Unpushed Flux operators & downsampling roll-up gaps
Ongoing InfluxDB SRE

Keep telemetry ingestion fast and stable.

Continuous cardinality and WAL monitoring, shard lifecycle care, backup drills, and incident response under a 24x7 support agreement or in covered business hours.

  1. Page on-callavailable where your service agreement includes it
  2. 15 minP1 initial-response target
  3. Written RCAafter every P1 incident
Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
TSI Index Memory Allocation & File Cache SizingTunes max-index-log-file-size, series-id-set-cache-size, and OS page cache residency, eliminating TSI memory thrashing and reducing p99 series lookup latency.Leaves index-version at in-memory defaults or fails to size OS page cache for TSI, triggering kernel OOM terminations under heavy ingestion.Recommends vertical node scaling or arbitrary RAM increases without auditing series key turnover or disk cache hit rates.Deletes TSI index files manually on disk without rebuilding series files, causing permanent catalog corruption.
Write-Ahead Log (WAL) Flush & Cache Snapshot ErgonomicsCalibrates cache-snapshot-memory-size and cache-snapshot-write-cold-duration to optimize TSM snapshot flushes and prevent WAL disk saturation.Allows WAL directory to compete for I/O with TSM data directories on shared storage, creating write-stall bottlenecks during traffic spikes.Increases WAL buffer size blindly without adjusting flush intervals, exacerbating memory pressure during crash-recovery replays.Disables WAL sync calls to boost raw write speed, risking catastrophic uncommitted telemetry data loss during node failures.
DataFusion Vectorized Query Plan Optimization (3.x)Optimizes InfluxDB 3.x Apache Arrow DataFusion query execution, partition chunk boundaries, predicate pushdown, and SQL parallel scan degrees of parallelism.Executes unindexed wildcards and high-cardinality GROUP BY queries across raw Parquet files without partition pruning.Attempts to port unoptimized Flux query logic directly to SQL, ignoring DataFusion columnar execution rules and memory limits.Issues unbounded SELECT * queries across multi-terabyte buckets, overwhelming DataFusion executor memory pools.
Continuous Query & Downsampling Aggregation LatencyDesigns multi-tier scheduled downsampling (raw -> 1m -> 1h) with non-overlapping RESAMPLE intervals, eliminating continuous query CPU spikes.Schedules overlapping Continuous Queries across all raw measurements at midnight, causing massive cluster lockouts and delayed reports.Replaces database continuous queries with external cron Python scripts that pull billions of raw rows across the network.Runs high-frequency client-side aggregations directly against raw data, bypassing downsampling tables entirely.
Telegraf Batch Buffering & Jitter CalibrationOptimizes metric_batch_size, flush_interval, flush_jitter, and retry backoff across collector fleets, ensuring smooth line-protocol delivery without write bursts.Configures identical flush intervals across thousands of Telegraf agents without jitter, creating periodic 'thundering herd' write spikes.Sets tiny batch sizes of 100 metrics, creating extreme HTTP connection overhead and exhausting InfluxDB connection pools.Ignores agent buffer limits and network dropouts, leading to silent metric omission during upstream network pauses.
Parquet Compaction Planner & Worker SizingSizes InfluxDB 3.x background compaction workers, target Parquet file sizes, and object-storage sync cadences to maintain sub-second query scans.Leaves compactor worker threads at defaults, resulting in thousands of tiny uncompacted Parquet files and bloated S3 API scan latency.Attempts external cron-based compaction scripts that conflict with native InfluxDB 3.x object store lifecycle managers.Disables background compaction to reduce CPU utilization, resulting in exponential query degradation over time.

Time-series platforms and ingestion stacks we tune

For procurement and platform security teams

Mutual NDA first, read-only diagnostics, and written latency scope

We diagnose InfluxDB bottlenecks using read-only `_internal` metrics, `reporttsi` index summaries, and slow query logs. Your team approves every Telegraf and storage config update before rollout.Raguraman, Engineering Manager · Allen D, Lead Database SRE
  • Mutual NDA
  • Written statement of work
  • Named engineers
  • Read-only diagnostics
  • NDA before access

    Signed before any diagnostic session. The initial scoping call requires no database credentials.

  • Written statement of work

    Target instances, cardinality and latency goals, deliverables, and fees agreed in writing first.

  • Read-only by default

    We inspect `_internal` metrics, `reporttsi` summaries, and query plans through your bastion or VPN.

  • Configs & queries you keep

    Every `config.toml` diff, Telegraf processor rule, and query rewrite stays with your team. Meet the JusDB team.

JusDB's security practices are aligned with ISO 27001 and SOC 2 Type II, and JusDB is pursuing both certifications (see Terms, section 12). Read the stated status.

Technical FAQ

InfluxDB performance tuning common questions

Answers on cache-max-memory-size errors, `reporttsi` cardinality diagnostics, Flux vs InfluxQL speed, TSM compaction throttling, and v3 IOx Parquet pruning.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

How do you fix HTTP 500: engine: cache-max-memory-size exceeded in InfluxDB?

This error occurs when incoming Line Protocol writes fill the in-memory WAL cache faster than TSM snapshot compactions can flush data to disk. We resolve it by (1) moving `wal-dir` onto low-latency local NVMe or provisioned-IOPS SSDs, (2) raising `storage-cache-max-memory-size` (e.g., from 1 GiB to 4-8 GiB) and `storage-cache-snapshot-memory-size` (to 64-128 MiB), (3) batching Telegraf writes to 5,000-10,000 points with `flush_jitter`, and (4) reducing TSI series cardinality so snapshots flush faster.

How do you find which measurement or tag key is causing high series cardinality?

We run `influx_inspect reporttsi -db-path /var/lib/influxdb2/engine/data -top 20` on the data directory (or query `influxdb.cardinality()` / `_internal` metrics) to get an exact breakdown of series count per bucket, measurement, and tag key. Once we identify the unbounded tag (such as `container_id`, `pod_uid`, or `session_id`), we add a Telegraf `processors.converter` rule to write it as a field instead of a tag.

Why is InfluxQL often much faster than Flux on the same InfluxDB 2.x data?

InfluxQL compiles directly into storage-engine iterators that stream and aggregate TSM series blocks with minimal memory allocation. Flux constructs intermediate tabular data frames in the Go runtime; if any pipe stage breaks storage pushdown (such as `pivot()`, `join()`, or filtering on `_value` before aggregating), Flux pulls millions of raw points into Go heap. We either refactor Flux using `import "profiler"` to ensure full storage pushdown or switch Grafana dashboards to the native InfluxQL endpoint.

How do you tune TSM compaction so it does not saturate disk I/O during peak hours?

If TSM level-4 and full compactions run too aggressively on shards that are still receiving late writes, disk I/O spikes and starves live queries. We increase `storage-compact-full-write-cold-duration` (e.g., from `4h` to `8h` or `12h`) so full compactions only run on truly cold shards, and set `storage-compact-throughput` and `storage-compact-throughput-burst` (e.g., 128-192 MiB/s) so background compactions never consume all NVMe bandwidth.

How do you optimize query performance in InfluxDB 3.0 (IOx Apache Arrow/Parquet)?

In InfluxDB 3.0 IOx, performance is governed by Parquet file partitioning and Apache DataFusion query plans rather than TSI indexes. We design custom table partition templates that combine a time interval (such as `YYYY-MM-DD`) with your primary filter tags (such as `region` or `tenant_id`), run `EXPLAIN ANALYZE` in SQL/FlightSQL to verify Parquet row-group min/max pruning, and tune Querier in-memory Parquet caches.

What are the best Telegraf settings for high-throughput InfluxDB ingestion?

For high-velocity telemetry, we set `metric_batch_size = 5000` to `10000`, `metric_buffer_limit = 100000+`, `flush_interval = "10s"`, and `flush_jitter = "5s"` so hundreds of agents do not hammer InfluxDB at the exact same millisecond. We also enable `content_encoding = "gzip"` on `[[outputs.influxdb_v2]]` to cut network payload bandwidth by 80%+.

Why did running a DELETE query make our InfluxDB instance slow for hours?

InfluxDB TSM files are immutable column blocks. Running a `DELETE` statement writes `.tombstone` files and forces the TSM compaction engine to read, filter, and rewrite every affected `.tsm` file on disk. For routine data expiration, we replace manual `DELETE` jobs with properly sized bucket retention policies and aligned shard group durations so expired shards unlink instantly.

What are your initial-response targets for InfluxDB latency and outage incidents?

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

Next step

Talk to an engineer about tuning your InfluxDB deployment

Share your InfluxDB version, series cardinality, WAL error logs, and query latency targets. The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance, subject to availability: mutual NDA before read-only access, a prioritized report within one week after access is ready, and no obligation.

NDA before access · read-only by default · written scope first