What You'll Learn at Unlocked

Enjoy a complimentary breakfast

Kick-start the day with a foreword from Khawaja Shams and Mas Kubo

Valkey's momentum is being driven by something bigger than any single company: an energized global community of builders, operators, and contributors. In these opening remarks, Sailesh Krishnamurthy, VP of Engineering at Google Cloud, shares why open collaboration is driving rapid innovation across the ecosystem, how Google is investing in that future, and what it means for teams building modern, high-performance systems.

The real test of a system happens at 3 AM because while you're sleeping, operational predictability becomes far more valuable than "Day 0" hype. We'll explore how benchmarks may be lying to you, why predictability is more important than hype, and how Valkey is investing in Day 2 operations with community-led features like Forkless Sync and Atomic Slot Migration to help you sleep at night.

Maintaining a popular open-source project means most of your day goes to ceremony: routing issues, classifying PRs, chasing follow-ups, coordinating releases. The ceremony is mechanical, repetitive, and constant. Traditional software isn't architected to solve these problems. It waits to be driven, so the maintainer ends up being the human runtime.
This session introduces a new kind of software called "living apps": software with the agency to drive ceremony, the durability to execute reliably, and the discipline to escalate when judgment is required. We'll demo valkey-oss-triage, one such living app watching the live valkey-io/valkey inbox and running on Valkey itself, and share what it takes to build a fleet of these in natural language.

Building a production-grade Valkey client library in Swift is more than just wrapping a protocol; it’s about moving reliability guarantees directly into the compiler. We’ll share the hard-earned lessons from crafting a native, cluster-aware library that leverages Swift’s structured concurrency to handle high-scale distributed state, the design decisions needed to maintain 400+ commands, and the challenges of managing API stability across complex systems. This session dives into how we modeled for "worst-case" production scenarios to ensure stability during volatile connection storms. These lessons are applicable to anyone designing production-grade client libraries in any language.

Time for the hallway track

Modern AI applications are increasingly dominated by Large Language Model (LLM) calls which are expensive, slow, and often repetitive. Traditional caching works well for exact matches, but it fails when user queries are phrased differently yet mean the same thing. This session explores how Valkey can power semantic caching to dramatically reduce LLM costs, lower latency, and improve system scalability.

Read-heavy workloads are well-documented, but write-intensive Valkey deployments surface a different class of problems: persistence tradeoffs, replication lag, memory pressure, and event loop contention. Learn about the configuration decisions and operational patterns that matter most when writes dominate your traffic profile, with concrete tuning drawn from production at Snap.

Why should a 50GB database require 100GB of RAM just to take a backup? Valkey’s Forkless Save capability decouples data persistence from the memory-intensive forking process, eliminating the memory spikes that lead to OOM issues. We will compare traditional fork-based persistence against the new forkless model, highlighting the impact on system resource utilization. Learn how Valkey helps you configure your clusters for true operational stability.

In high-performance systems, we often treat 100% CPU utilization as a hard ceiling—a signal to scale up or brace for impact. But in Valkey, the numbers on your dashboard can be deceptive. This talk explores the intricate relationship between Valkey’s main and IO threads and reveals why traditional utilization metrics often fail to reflect actual workload capacity. We will dive into the "hidden headroom" that exists even when your cores appear saturated, and introduce the new observability primitives arriving in Valkey 9.1 that finally distinguish between system activity and productive work. Attendees will walk away with a new mental model for interpreting engine telemetry and a strategy for scaling that goes beyond the "busy" signal.

Time to refuel for an afternoon of learning!

As applications go global, keeping clusters synchronized across geographically separated data centers becomes a critical operational requirement. This session explores how Apple built a durable geo-replication architecture using open-source technologies to ensure near real-time data availability and disaster recovery. We will dive into the design of using Apache Kafka as a replication layer for Valkey operations, ensuring data durability across clusters even if a primary cluster fails. We will discuss the trade-offs in latency, conflict resolution, and monitoring at scale, as well as how these real-world learnings are shaping the future of native active-active geo-replication within the Valkey core.

Integrating full-text search into an in-memory ecosystem requires capabilities that differ from traditional KV workloads. This session explores Valkey Search 1.2, focusing on how it handles index-based, multi-threaded queries without sacrificing performance. We’ll look at how hybrid queries combine vector similarity with numeric, text, and tag filters in a single pass. You’ll also learn the strategies behind index definition and usage that enable Valkey Search to scale to terabytes of data while remaining operationally predictable.

Envoy's plugin model opens powerful possibilities for storage proxies, but building one that holds up under high-throughput production traffic requires careful attention to threading models, buffer management, and filter chain design. Learn the architectural foundations for writing storage-aware Envoy plugins that don't become the bottleneck, with concrete patterns drawn from operating these systems at Snap's scale.

In this talk, we want to walk through our evolution from simple caching with Memcached to operating Redis at massive scale, where it became a critical component for both caching and ML feature serving. As our usage grew, we faced increasing challenges around cost, operational complexity, and scalability limits of Redis clusters. These constraints motivated a shift toward Valkey, where we focus on improving efficiency through better access patterns, memory optimization, and scalable architecture—ultimately achieving significant gains in performance, cost, and system stability.

Have a stretch, talk some shop.

Deploying Valkey in cloud environments requires security defaults that are both rigorous and easy to operate. This session dives into the recent work Apple contributed to Valkey’s TLS implementation to solve the challenges of certificate lifecycle management and runtime predictability. We will examine the architecture behind automatic TLS configuration reloading and certificate-based client authentication via SAN URIs, while highlighting how new ACL guardrails prevent privilege escalation. Learn how these improvements move Valkey toward a "secure by default" model that handles certificate rotation and validation without impacting availability.

Strip away the GPUs and the transformer math, and modern inference looks suspiciously like something you've already built a hundred times: a caching stack. Same patterns, same tradeoffs, wildly different domain. Join Daniela, CTO at Momento, and Samuel Shen, Software Engineer at Tensormesh, as they trace the lineage from the caches you know to the KV caches feeding today's LLMs: where the instincts transfer, and where they'll mislead you. Then a deep dive into LMCache, the open-source KV cache leading the space, and how much your client implementation is costing you on the tail.

Not all applications can rely on native clients with connection pooling, especially in fork-based worker models where process-level pooling is impossible. This session explores strategies required to manage massive connection scale through a custom RESP proxy. We examine different approaches to request and connection management, such as connection pinning and multiplexing, and why getting centralized circuit breaking right is critical at scale. You’ll learn how we implement AZ-aware routing using real-time latency metrics to automatically bypass problematic nodes, and the challenges of building high-performance proxy components when the implementation language is already chosen for you.

At Netflix, demand-filled caches power critical use cases at massive scale, but a much larger share of our caching footprint is served through a different paradigm: versioned caches. These are snapshot-published datasets with periodic delta application, spanning from in-client-process mutable stores with nanosecond reads to distributed petabyte-scale datasets atomically published from offline jobs. This talk explores four versioned caching architectures that Netflix operates at scale across varying dimensions like consistency, latency, mutability, and dataset size- and how versioned caches sidestep entire classes of problems of traditional caches and what they trade off in order to do so. These patterns offer compelling ideas for the broader caching community to explore.

Light refreshments

Introducing Valkey Lab, a new open-source tool designed to simulate real-world traffic patterns and measure metrics that actually matter. We’ll demonstrate how Valkey Lab can help tune your clusters for specific read/write ratios and target TPS, ensuring your infrastructure is ready for the "tail latency" spikes that other tools miss. See a live demo of the latest performance gains in Valkey, measured and verified in real-time.

Distributed systems often trade consistency for latency, but in a billing system, that trade-off is unacceptable. This talk examines the mechanics of 'Cache Drift' in Valkey-backed architectures. We’ll explore the specific edge cases, including partial failures, retry loops, and async replication, that lead to state divergence and how to solve them using idempotency, reconciliation, and safer write patterns. The talk focuses on the real-world tradeoffs between consistency and latency and ways to make the right trade-offs for financial production systems.

Caching is supposed to make everything faster—until it doesn't. Join Madelyn, a Principal Engineer at Amazon ElastiCache, and Khawaja, CEO at Momento, as they go "off-script" to share unfiltered stories from years spent keeping high-performance caching systems alive under the most demanding production conditions. This session focuses on what actually goes wrong at scale, from request cascades that turn minor traffic spikes into full-blown outages to unanticipated large-scale failures. You’ll learn how to think about failure modes in high-performance systems and—more importantly—how to avoid getting 3AM pages.

Time for fun, networking, and unwinding.