Free audit

View Audit Scope
Valkey 8.0 PerformanceAsync io-threads · Jemalloc activedefrag · Sub-ms p99

Valkey Performance Tuning & Latency Optimization

JusDB provides Valkey 8.0 and 7.2 performance tuning, sub-millisecond p99 latency optimization, and jemalloc memory defragmentation for high-throughput BSD-3 in-memory workloads. Our database reliability engineers calibrate async io-threads, eliminate single-threaded event-loop stalls caused by big keys and blocking Lua scripts, tune maxmemory eviction policies, and remediate copy-on-write fork spikes.

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 scope before work starts

Valkey 8.0 performance & memory subsystems

Select a subsystem to inspect

Valkey 8.0 Async I/O Threading

1M+ RPS per node

Valkey 8.0 offloads socket reads,RESP parsing, TLS handshakes, and network writes across dedicated I/O threads while preserving atomic command execution.

Setting io-threads 4 and io-threads-do-reads yes requires careful CPU core pinning so I/O threads never contend with the primary command loop or BGSAVE forks.

Inspect Valkey 8.0 valkey.conf tuning

Verified against Linux Foundation BSD-3 Valkey 8.0 vs Redis 7.2 specifications.

Valkey subsystems tuned
Valkey 8.0 io-threads, jemalloc activedefrag, maxmemory-policy, CoW BGSAVE forks, and 16,384 Cluster hash slots
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 a 24x7 support agreement

Selected clients

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

Production failure modes

Common Valkey latency and memory bottlenecks we resolve

Because Valkey executes data-structure commands atomically on a single main thread, one unindexed Lua script, multi-megabyte key eviction, or Transparent Huge Page fork stall immediately degrades p99 latency across every connected service.

Valkey production performance symptoms, root causes, and first diagnostic actions
Valkey / INFO signalWhat is usually happeningWhere we start
p99 > 15ms (Big Keys)Single-thread event loop stalls on multi-megabyte hashes or setsCommands like HGETALL, SMEMBERS, or synchronous DEL on keys holding hundreds of thousands of elements monopolize the main execution thread and queue all concurrent clients.Run valkey-cli --bigkeys and MEMORY USAGE sampling on a read replica, replace O(N) scans with HSCAN/SSCAN cursors, and enable lazyfree-lazy-server-del yes.
mem_fragmentation_ratio > 1.5Host RSS climbs toward OOM despite stable used_memoryHigh-churn variable-sized values leave partially empty jemalloc slabs that cannot be returned to the OS, starving BGSAVE fork headroom.Inspect MEMORY STATS and MEMORY MALLOC-STATS, enable activedefrag yes, and bound active-defrag-cycle-min 2 and active-defrag-cycle-max 15.
latest_fork_usec > 50000Periodic latency cliffs every time RDB BGSAVE or BGREWRITEAOF runsTransparent Huge Pages (2 MiB THP) force the kernel to copy entire 2 MiB blocks on any single-byte write during a persistence child process.Set transparent_hugepage/enabled to never, configure sysctl vm.overcommit_memory=1, and move scheduled RDB/AOF snapshots off the primary onto a dedicated replica.
CROSSSLOT / Hot ShardOne Valkey Cluster node hits 95% CPU while sibling primaries sit idleCelebrity cache keys or poorly designed {hashtag} locality rules funnel disproportionate read/write traffic into a single hash slot out of 16,384.Run valkey-cli --hotkeys under LFU tracking, enable client-side caching (CLIENT TRACKING) or read-from-replica routing, and split coarse hash tags.
evicted_keys stormWrite latency spikes and cache hit ratio collapses at maxmemoryInstance reaches maxmemory under volatile-lru or synchronous eviction, forcing the main thread to evict large objects inline before accepting each write.Benchmark allkeys-lfu vs volatile-lfu for power-law access patterns, enable lazyfree-lazy-eviction yes, and reserve 25-30% RAM below physical host memory.
client_longest_output_listPub/Sub or pipeline buffer bloat triggers sudden client disconnectsSlow consumers or unthrottled MONITOR / SUBSCRIBE sessions accumulate gigabytes in client output buffers, eating into maxmemory and triggering OOM evictions.Audit CLIENT LIST omem values, enforce strict client-output-buffer-limit pubsub and replica thresholds, and implement RESP3 pipelined batching.

Technical scope

What does our Valkey performance tuning service include?

We audit and tune your Valkey configuration, Linux kernel sysctls, persistence topology, and application connection pools with reproducible before-and-after latency evidence.

  • Valkey 8.0 async io-threads & CPU pinning

    Valkey 8.0 introduces dual-mode asynchronous I/O threading and enhanced memory prefetching. We calibrate thread counts and NUMA affinity so network serialization scales without lock contention.

    • Benchmark io-threads 4 to 8 with io-threads-do-reads yes under production TLS and RESP payloads
    • Pin main event loop, bio_* background threads, and I/O workers across physical CPU cores

    io-threads · io-threads-do-reads · taskset / cpuset · valkey-benchmark

    Redis vs Valkey 8.0 engineering comparison
  • Jemalloc activedefrag & maxmemory sizing

    We eliminate surprise Linux OOM kills by modeling the exact memory budget across dataset overhead, replica output buffers, AOF rewrite buffers, and CoW fork pages.

    • Tune active-defrag-threshold-lower/upper and cycle budgets for sub-millisecond p99 safety
    • Configure maxmemory to 65-75% of host RAM with allkeys-lfu or volatile-lfu policies

    MEMORY STATS · MEMORY DOCTOR · activedefrag · jemalloc arenas

  • Big-key, hot-key & Lua script latency removal

    A single O(N) command or unindexed Lua script stalls every connected microservice. We isolate offending keys and refactor access patterns into bounded O(1) or cursor operations.

    • Non-blocking replica scans using --bigkeys, --memkeys, and LFU --hotkeys
    • Enable lazyfree-lazy-eviction, lazyfree-lazy-expire, and lazyfree-lazy-user-del

    SLOWLOG GET · LATENCY DOCTOR · LATENCY GRAPH · lazyfree-*

  • RDB & AOF persistence fork optimization

    Disk persistence should never stall in-memory commits. We tune Linux kernel virtual memory and Valkey fsync mechanics to flatten BGSAVE and BGREWRITEAOF tail latency.

    • Disable Transparent Huge Pages (THP) and configure vm.overcommit_memory=1 and somaxconn
    • Tune appendfsync everysec, no-appendfsync-on-rewrite yes, and aof-use-rdb-preamble

    BGSAVE · BGREWRITEAOF · latest_fork_usec · aof-rewrite-incremental-fsync

  • Cluster 16,384 hash-slot & pipeline tuning

    In multi-shard Valkey Cluster deployments, network round-trips and unbalanced hash tags dominate application p99 latency. We optimize slot topology and client pooling.

    • Rebalance skewed 16,384 hash slots and eliminate CROSSSLOT multi-key bottlenecks
    • Configure Lettuce, Jedis, ioredis, and go-redis connection pools and RESP3 pipelining

    CLUSTER SLOTS · CLIENT TRACKING · RESP3 · TCP_NODELAY

    Valkey Cluster architecture
  • Prometheus observability & latency alerting

    Average latency hides micro-bursts. We deploy granular histograms and saturation alerts that catch fork stalls, buffer bloat, and replication link drops before incidents escalate.

    • Instrument redis_exporter for Valkey 8.0 metrics, slowlog rates, and fork duration
    • Configure P1/P2 alert thresholds on evicted_keys, rejected_connections, and master_link_status

    Prometheus redis_exporter · Grafana · LATENCY HISTOGRAM · INFO Everything

    Valkey 24x7 support (where contracted)

Shared responsibility & response targets

Where default Valkey configurations stop and what JusDB engineers run

Out-of-the-box Valkey packages and managed cloud caches ship with conservative single-threaded defaults; tuning io-threads, memory fragmentation, and CoW fork safety requires deep engine telemetry.

Comparison between default Valkey or cloud cache settings and what JusDB database engineers configure
Valkey subsystemWhere default setups stopWhat JusDB engineers run
Valkey 8.0 multi-threaded I/OShips with io-threads disabled (single-threaded network read/write) or generic cloud defaults that ignore TLS overhead.Benchmarks and enables io-threads 4+ with io-threads-do-reads yes, pinning worker threads to dedicated vCPUs away from the main event loop.
Memory ceiling & OOM protectionLeaves maxmemory unbounded on self-hosted Linux or sets static cloud limits that fail during copy-on-write BGSAVE forks.Calculates exact CoW fork and client-output-buffer headroom, enforces lazyfree-* asynchronous freeing, and tunes jemalloc activedefrag.
Tail latency (p99 / p99.9) spikesReports 5-minute average CPU and memory metrics in cloud dashboards, masking 50ms micro-stalls from big keys or THP.Captures microsecond LATENCY HISTOGRAM and SLOWLOG traces, disables Linux THP, and refactors blocking O(N) commands and Lua scripts.
AOF & RDB persistence stallsRuns scheduled snapshots directly on the primary node with default fsync settings that stall writes under disk contention.Offloads RDB/AOF snapshots to dedicated persistence replicas, enables no-appendfsync-on-rewrite yes, and tunes incremental fsync.
Hot keys & cluster slot skewDistributes slot ranges evenly by count (16,384 / N) without inspecting actual key access frequency or memory footprint per slot.Profiles LFU hot keys and slot memory distribution, redesigns {hashtag} policies, and configures client-side caching or read-replica routing.
Client driver & connection poolingStops at the Valkey socket boundary; reconnect storms and unpipelined request waterfalls remain an application problem.Tunes Lettuce, ioredis, go-redis, and Predis pool sizes, pipeline batching, DNS TTLs, and cluster topology refresh intervals.

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 latency & memory simulator

How Valkey 8.0 threading and defrag stabilize tail latency

Compare an uncalibrated single-threaded node suffering THP copy-on-write fork stalls against active defragmentation and a fully tuned Valkey 8.0 io-threads deployment.

Valkey 8.0 latency, memory & I/O threading simulator

Select a state to inspect event-loop utilization, jemalloc fragmentation, and persistence fork behavior.

Client Socket Pool, RESP Parser & Event Loop

All TLS decryption, socket reads, O(N) big-key scans, and BGSAVE page-table copies contend on one CPU core while sibling vCPUs sit idle.

p99 42ms · Main loop blocked on TLS + THP fork
  • valkey-primary-01 (Main Thread)

    Command loop + Socket I/O + TLS

    SATURATED · 99% Core 0 · p99 42ms

  • bgsave-child (PID 41892)

    RDB snapshot fork with 2 MiB THP

    COW STALL · latest_fork_usec 84,000

  • jemalloc Heap (64 GiB Host)

    Unbounded fragmentation · Synchronous DEL

    WARN · mem_fragmentation_ratio 1.62

Without Valkey 8.0 async I/O threading and kernel THP remediation, network serialization and copy-on-write forks freeze the single command thread, causing cascading application timeouts.

Representative production deliverable

How a Valkey 8.0 latency and memory audit is delivered

Every tuning recommendation includes the INFO and LATENCY HISTOGRAM evidence, the exact online CONFIG SET or valkey.conf patch, and kernel sysctl guardrails.

Sample finding · TLS single-thread saturation & jemalloc CoW fork stallValkey 8.0.1 · 64 GiB RAM · 16 vCPU

Finding

Single-threaded TLS reads and 2 MiB Transparent Huge Pages spike p99 latency to 38ms

Despite running on a 16-vCPU instance, io-threads defaulted to 1, forcing Core 0 to handle all TLS decryption and socket writes. Meanwhile, enabled Linux THP caused latest_fork_usec to exceed 78ms during RDB snapshots with mem_fragmentation_ratio at 1.54.

GET/SET p99 latency38.2ms to 0.41ms
Fragmentation ratio1.54 to 1.07

1. Production valkey.conf: Enable Valkey 8.0 io-threads, lazyfree, and bounded activedefrag

valkey.conf · Valkey 8.0 latency & memory profile

# Valkey 8.0 multi-threaded network I/O (requires restart for io-threads count)
io-threads 4
io-threads-do-reads yes

# Reserve 30% RAM headroom for CoW forks and replica buffers on 64 GiB host
maxmemory 45gb
maxmemory-policy allkeys-lfu

# Offload O(N) deletions and evictions to bio_lazy_free background threads
lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes
lazyfree-lazy-user-del yes

# Bounded jemalloc active defragmentation (online adjustable via CONFIG SET)
activedefrag yes
active-defrag-ignore-bytes 200mb
active-defrag-threshold-lower 15
active-defrag-threshold-upper 100
active-defrag-cycle-min 2
active-defrag-cycle-max 15

2. Linux kernel CoW fork guardrails & live latency verification

bash · sysctl & valkey-cli verification

# Disable Transparent Huge Pages and allow optimistic fork memory overcommit
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
sysctl -w vm.overcommit_memory=1 net.core.somaxconn=65535

# Verify fragmentation recovery, fork duration, and sub-millisecond histogram
valkey-cli INFO memory | grep -E "used_memory_human|used_memory_rss_human|mem_fragmentation_ratio|maxmemory_policy"
valkey-cli LATENCY HISTOGRAM get set hgetall

Ways to work together

How to engage JusDB for Valkey performance tuning

Start with a free read-only audit of one Valkey node or cluster, scope a focused latency and memory optimization engagement, or put your Valkey estate under ongoing DBA coverage.

Scoped tuning projectThis page

Eliminate p99 latency spikes and OOM pressure.

A fixed-scope engagement with written findings, staging benchmark validation, and safe production rollout alongside your platform team.

Common tuning scopes agreed in writing first

  • Valkey 8.0 io-threads calibration
  • activedefrag & maxmemory sizing
  • Big-key & hot-key refactoring
  • RDB/AOF fork stall removal
  • 16,384 hash-slot rebalancing
Free Valkey audit

One Valkey instance or shard, audited read-only.

We inspect your INFO memory/stats output, LATENCY HISTOGRAM, slowlogs, and persistence fork timings, then deliver a prioritized report within one week.

What we check on your Valkey instance

  • Valkey 8.0 io-threads readiness & CPU core saturation
  • Jemalloc fragmentation, big keys & eviction policy fit
  • BGSAVE / AOF copy-on-write fork latency exposure
Ongoing Valkey DBA & support

Named engineers covering your Valkey estate.

Proactive Prometheus exporter monitoring, capacity modeling, failover drills, and incident response available under a 24x7 support agreement.

  1. Page on-callavailable under a 24x7 support agreement
  2. 15 minP1 initial-response target
  3. Written RCAafter every P1

Valkey platforms and runtimes we tune

Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
Multi-Threaded I/O (io-threads) Thread Pool CalibrationProfiles socket read/write CPU utilization, calibrating io-threads and io-threads-do-reads based on core NUMA topology to exceed 1.2M ops/sec while eliminating main event loop stalls.Leaves Valkey operating on single-threaded default configurations, severely bottlenecking throughput on high-core cloud instances.Oversubscribes io-threads past available physical CPU cores, inducing kernel context-switching thrashing and increasing tail latency.Unaware of Valkey multi-threading internals; attempts horizontal sharding when simple multi-threaded I/O calibration would solve the bottleneck.
jemalloc Active Memory Defragmentation OptimizationCalibrates activedefrag parameters (active-defrag-ignore-bytes, active-defrag-threshold-lower/upper, active-defrag-cycle-min/max) and MALLOC_CONF dirty page purging to keep fragmentation ratio under 1.25.Relies on ad-hoc node restarts during production hours to reclaim memory from high mem_fragmentation_ratio, causing cache drops.Leaves activedefrag disabled or enables it with default aggressive cycles that consume 25%+ main-thread CPU during peak traffic.Assumes memory fragmentation is a memory leak; continuously increases node instance RAM sizing rather than tuning jemalloc allocators.
Maxmemory Eviction Policy & High-Water Mark SizingProfiles key TTL distributions and access skew to select optimal eviction policies (allkeys-lru, volatile-lfu, noeviction) with custom maxmemory-samples tuning and client buffer guardrails.Sets maxmemory to 95% of total system RAM, leaving insufficient headroom for background forks and triggering Linux kernel OOM kills.Defaults to allkeys-random or generic LRU without analyzing working-set access patterns, resulting in premature eviction of hot cache entries.Runs without maxmemory limits; sudden burst writes exhaust host RAM, crashing both Valkey and co-located monitoring sidecars.
Kernel Network Stack & TCP Socket (somaxconn) TuningOptimizes Linux kernel network parameters: sysctl net.core.somaxconn=65535, tcp_max_syn_backlog, disables transparent huge pages (THP), and tunes tcp_rmem/wmem for burst concurrency.Retains default OS somaxconn (128), causing TCP backlog overflow, silent packet drops, and client connection timeout spikes under load.Blames cloud VPC networking for connection dropouts without inspecting kernel socket backlog or listen queue drops.Increases client application connection pool limits without tuning host socket descriptors, exacerbating connection refusal cascades.
BigKey & HotKey Profiling with Latency-Monitor TelemetryZero-impact bigkey and hotkey scans via latency-monitor, SLOWLOG, and memory usage telemetry; redesigns oversized hash/set structures into unbundled buckets to eliminate blocking.Runs raw KEYS * or blocking DEBUG OBJECT commands in production, freezing the single-threaded event loop for seconds.Ignores bigkey growth until single large collections cause multi-millisecond serialization delays and replica timeout disconnections.Stores monolithic multi-megabyte JSON payloads in single keys; experiences unexplained client read timeouts and network link saturation.
AOF/RDB Persistence Engine Fsync Latency ThrottlingCalibrates appendfsync everysec with no-appendfsync-on-rewrite yes, tunes disk write buffers, and schedules BGSAVE snapshots during minimum-write windows to prevent fork latency spikes.Allows concurrent AOF rewrites and background RDB saves, saturating disk I/O channels and blocking foreground client transactions.Configures appendfsync always for durability on high-throughput workloads, degrading write throughput by over 90%.Leaves persistence completely unmonitored; disk fills to 100% capacity from uncompacted AOF logs, causing Valkey to enter read-only mode.

For procurement and security teams

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

We work inside your security boundary via bastion hosts, VPN, or temporary cloud IAM roles. Your engineering team approves every CONFIG SET or valkey.conf change and keeps every benchmark script and runbook.Raguraman, Engineering Manager · Allen D, Lead Database SRE
  • Mutual NDA
  • Written statement of work
  • Named engineers
  • Least-privilege ACLs
  • NDA before access

    Signed before any diagnostic review. The 30-minute scoping call requires no credentials or cluster access.

  • Written statement of work

    Covered Valkey clusters, latency and memory deliverables, maintenance windows, and fees agreed in writing before work starts.

  • Read-only ACLs by default

    Named Valkey ACL accounts restricted to read-only INFO, SLOWLOG, LATENCY, and MEMORY inspection commands.

  • Runbooks you keep

    Every valkey.conf diff, kernel sysctl profile, and post-tuning report 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

Valkey performance tuning common questions

Answers on Valkey 8.0 async io-threads, jemalloc activedefrag, maxmemory eviction policies, CoW BGSAVE forks, and big-key detection.

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 does Valkey 8.0 improve performance compared to Redis 7.2?

Valkey 8.0 (licensed under BSD-3-Clause) introduces major performance engineering upgrades over Redis 7.2, including asynchronous multi-threaded network I/O (io-threads with io-threads-do-reads yes), dual-channel replication that runs RDB transfers concurrently with replication stream buffering, hash-table memory prefetching (__builtin_prefetch), and reduced per-key dictionary overhead. On multi-core hosts with TLS enabled, Valkey 8.0 regularly delivers over 1 million RPS per node.

What should we set io-threads and io-threads-do-reads to in Valkey 8.0?

For single-instance or clustered Valkey nodes that saturate a single CPU core on network serialization or TLS encryption, we typically enable io-threads-do-reads yes and set io-threads between 4 and 8 on hosts with at least 8 physical cores. Setting io-threads above 8 rarely improves throughput and can increase context-switch jitter unless threads are pinned away from the main event loop and kernel interrupt handlers.

Why does Valkey hit Linux OOM kills even when used_memory is below maxmemory?

maxmemory only governs the dataset heap tracked by Valkey. Total process RSS (used_memory_rss) also includes jemalloc fragmentation (mem_fragmentation_ratio), client output buffers (Pub/Sub and replica backlog buffers), AOF rewrite buffers, and copy-on-write (CoW) page duplication during BGSAVE or BGREWRITEAOF. We size maxmemory at 65% to 75% of physical RAM, bound client-output-buffer-limit, and disable Linux Transparent Huge Pages.

Which maxmemory-policy should we choose: allkeys-lfu, allkeys-lru, or volatile-lfu?

For dedicated look-aside caches where every key can be regenerated from a backing database, allkeys-lfu is almost always superior to allkeys-lru because its Morris counter frequency tracking prevents one-off batch scans from flushing hot working-set keys. When a Valkey instance mixes durable state (such as rate-limit locks or job queues without TTLs) alongside ephemeral cache keys, we configure volatile-lfu and enforce strict TTLs on cache namespaces.

How do you find and fix big keys and hot keys without stalling production?

We never run blocking KEYS * or full memory scans against a heavily loaded primary. Instead, we run valkey-cli --bigkeys, --memkeys, and --hotkeys (when LFU is active) with a throttled -i interval against a read replica, or analyze an off-host RDB snapshot using rdbtools. Once identified, we break monolithic hashes/sets into bucketed keys, replace DEL with UNLINK, and enable lazyfree-lazy-server-del yes.

Is jemalloc active defragmentation (activedefrag) safe to enable in production?

Yes, when bounded properly. Because activedefrag runs on the main execution thread in time-sliced cycles, aggressive settings (such as active-defrag-cycle-max 75) will cause p99 latency spikes. We configure conservative production bounds: activedefrag yes, active-defrag-ignore-bytes 200mb, active-defrag-threshold-lower 15, active-defrag-cycle-min 2, and active-defrag-cycle-max 15.

Can you tune managed AWS ElastiCache for Valkey and Google Cloud Memorystore?

Yes. While managed cloud services manage the underlying VM and OS kernel, parameter group settings (maxmemory-policy, activedefrag, lazyfree-*, io-threads, slowlog-log-slower-than, and client buffer limits), shard count vs node family sizing, and client driver pooling remain your team's responsibility. We tune both self-hosted Valkey and managed cloud Valkey estates.

What are your response targets for Valkey latency and performance 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 your Valkey latency and memory profile

Tell us which Valkey versions, node sizes, and cluster topologies you run. 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

Related Valkey Services

Explore more ways our Valkey experts can help with your database infrastructure.