Sandon Jacobs
Confluent, an IBM Company - Senior Developer Advocate
Raleigh, North Carolina, United States
Actions
Sandon Jacobs is a Developer Advocate at Confluent, based in Raleigh, NC. Sandon has two decades of experience designing and building applications, primarily on the JVM. His data streaming journey began while building data pipelines for real-time bidding on mobile advertising exchanges—and Apache Kafka was the platform to meet that need. Later work in television media and the energy sector included Kafka Streams, Kafka Connect, and provisioning Kafka infrastructure with various infrastructure as code frameworks.
Outside of work, Sandon is actively involved in his Indigenous tribal community. He serves on the NC American Indian Heritage Commission, and also as a powwow singer and emcee at many celebrations around North America. Follow Sandon on Twitter @SandonJacobs or Instagram @_sandonjacobs, where he posts about his powwow travels, family, golf, and more.
Area of Expertise
Topics
Kafka Flow: Taming Distributed Data with Kotlin Coroutines
Let's be real for a minute. People usually just ignore the Future returned from the standard Apache Kafka producer. Plus, if your microservices are pumping out events super fast, trying to handle all that thread management inside your Consumer.poll() loops can get messy really fast. While the classic Java Kafka client is solid, it often doesn't play nicely with modern, non-blocking Kotlin setups.
Good news, though! Kotlin Flows and Coroutines are here to be your event-driven superheroes. They transform that messy, callback-ridden setup into beautiful, thread-efficient data streams—which is one place where Kotlin shines. This whole declarative style—handling streams, backpressure, and lifecycle like a total pro—is what we're calling Kafka Flow.
We're going to build the ultimate Flow-based Kafka wrapper and reveal the essential "bridge" patterns. We'll show you the magic of using suspendCoroutine to turn those producer acknowledgments into a clean suspend function, and how to safely tuck the slow-poke consumer polling inside a smooth, declarative Flow. The real kicker is how Flow operators let you tackle the seriously hard stuff: fine-tuning backpressure, building rock-solid distributed retries, and managing the entire consumer lifecycle—all with elegant, functional code that actually looks awesome.
Swing by and see how "Kafka Flow" can finally get you out of the thread management business and help your event-driven services scale up effortlessly. Trust me, future you will be sending thank you notes.
Keynote: Be Ready for What's Next
AI is driving change, and data streaming makes it possible for me to adapt.
Going Beyond the Basics with the Kafka Streams DSL 🚀
There you are, the data streaming engineer. You’ve architected an event-driven application ecosystem - a land where microservices produce events to Apache KafkaⓇ, change data capture (CDC) socializes transactions to Kafka topics, and connectors bring data from external systems into this streaming universe.
Now you need to process these streams to create insightful data products for your organization. In a JVM shop, you’ve read the tales of Kafka Streams and implemented “word count” examples galore. That’s great, but there’s so much more.
Let’s dive into the declarative Kafka Streams DSL and explore the operators that turn simple applications into sophisticated stream processing engines. We'll talk stateful transformations, zooming in on joins, aggregations, and windowing - why they are essential for building real-time data pipelines.
Slides are good, code is better. So let’s look at code - both the implementations and how to unit test our stream processing applications.
Join me to level up your skills with the Kafka Streams DSL to bring insights from your data streams.
A Developer-centric Tour of Apache KafkaⓇ
The currency of the modern microservice architecture is real-time data, allowing applications to make informed decisions on the most recent relevant data our organization has to offer. Layer AI models into the mix and the demand for fast, reliable access to quality data grows exponentially. Apache KafkaⓇ has emerged as the de facto standard for event-driven architectures. But Kafka isn’t just some “dumb pipe” messaging system. Let’s take a developer’s level view at this immutable, partitioned, distributed, durable log.
Starting from the protocol level, we’ll unpack the key terminology of Kafka’s internals - topics, brokers, producers, consumers, and offsets. Then we’ll go a level deeper to demystify how a Kafka cluster delivers on the promises that power functionality at 80% of the Fortune 500. We’ll step beyond the slides to look at some Kafka client code, then end our discussion by looking at other parts of the Kafka ecosystem for event processing and connecting to external systems.
Whether you’re a seasoned Kafka professional or just Kafka-curious, there’s something for you in this talk to further your journey in building event-driven applications.
Zero to Data Streaming Platform in Under 15 Minutes
Data streaming engineers need tooling to efficiently provision, maintain, and evolve the data stream platform. The Confluent Terraform Provider does just that, providing human-readable infrastructure-as-code to build a Confluent Cloud environment in a matter of minutes.
In this session, we’ll start from a blank canvas and create a new environment - complete with an Apache KafkaⓇ cluster, stream governance, and processing with Flink. Next we’ll create Kafka topics, define data contracts and determine how to transform our input data. We won’t forget about security and access controls - so let’s create service accounts with the necessary roles and permissions. Finally, we’ll set it all in motion by streaming events into Kafka and querying the output of our new data pipeline.
When we’re done, you’ll have the tools needed to build and maintain your data streaming platform. Let’s do this!
Folks, THIS is Apache Kafka
On day one of Green Bay Packers’ training camp each season, legendary coach Vince Lombardi stood before his team holding a “pigskin” and said: “Gentlemen, THIS is a football.” This highlights the importance of the basic fundamentals of any subject. In an ecosystem like Apache Kafka, it’s imperative that we understand the pieces and parts that compose this “highly scalable event streaming platform.”
In this session, let’s (re)introduce ourselves to the components of Apache Kafka. We’ll start with terminology like topics, partitions, producers and consumers - basic “blocking and tackling.” Along the way we’ll delve into how each is related and significant to the others. We’ll also take a high-level look at “special teams” aspects of the Apache Kafka ecosystem for data governance, connecting to external systems, and event processing.
I’m no Vince Lombardi. But you’ll walk away from this session with a basic understanding of how Kafka does what it does, as well as a curiosity to explore Kafka as a useful and powerful tool in your application architecture.
Building Event-Driven Microservices with Spring Boot, Apache Kafka® and Kotlin
So, I hear you’re developing Spring applications and microservices. Along comes event streaming with Apache KafkaⓇ and you need to integrate. As fate would have it, Spring and Kafka are already pretty good friends. This means you can leverage your organization’s expertise in building, testing, deploying, and monitoring Spring applications, while also reaping the benefits of event-driven design.
But why bore ourselves with yet another Java microservice. Kotlin is a first class citizen of the Spring framework. It’s proven itself as a popular language with constructs to simplify JVM-based development. And not just for cross-platform development, but for server-side implementations with frameworks like Spring, Ktor, and Micronaut - just to name a few.
In this session, I’ll walk you through writing a solution in Kotlin for producing and consuming Kafka events using Spring Kafka. We’ll highlight the Spring configuration involved in binding our application to a Kafka cluster in Confluent Cloud. We’ll use structured data - serialized with Apache Avro® - whose schemas are managed and governed by a schema registry.
When we’re done, you’ll be ready to explore this Spring-Kafka-Kotlin friendship for yourself.
What Can You Do with a (Kafka) Queue?
Apache Kafka has established itself as the leading platform for event streaming, yet architects and engineers have often turned to other systems to fulfill point-to-point messaging needs. With KIP-932—Queues for Kafka—Kafka now natively supports queue-like semantics.
In this session, we’ll dive into the cooperative consumption model that brings message-level acknowledgments to Kafka via the new ShareConsumer API. We’ll trace the journey of a message and demonstrate how developers can programmatically manage message state. Queue-driven tasks are often long-running, with a non-deterministic return time - and the API has this use case covered, as well. Observability is essential in distributed systems - so we’ll also explore the metrics and configuration options that provide essential visibility. Finally, we’ll walk through some sample code - because slides never make it to production.
Queues for Kafka give developers a seamless way to meet messaging requirements using the Kafka protocol—without altering how messages are produced. This solution delivers point-to-point messaging with all the core guarantees of Apache Kafka, including durable storage, horizontal scalability, and fault tolerance. Discover how “queues the Kafka way” can elevate your messaging architecture.
Current New Orleans 2025 Sessionize Event
Current London 2025 Sessionize Event
Devnexus 2025 Sessionize Event
Current 2024 Sessionize Event
Sandon Jacobs
Confluent, an IBM Company - Senior Developer Advocate
Raleigh, North Carolina, United States
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top