Introduction

In Kafka Streams, writing to a topic means sending a stream or table result to a sink node in the topology. The most common API for this is to(...) on a KStream, and the important detail is that the output topic needs the right serializers, or more precisely the right Kafka Streams serdes.

The Basic Pattern Is stream.to(...)

A minimal Kafka Streams application reads from one topic, transforms the records, and writes the result to another topic.

1import java.util.Properties;
2import org.apache.kafka.common.serialization.Serdes;
3import org.apache.kafka.streams.KafkaStreams;
4import org.apache.kafka.streams.StreamsBuilder;
5import org.apache.kafka.streams.StreamsConfig;
6import org.apache.kafka.streams.kstream.KStream;
7
8public class StreamsApp {
9    public static void main(String[] args) {
10        Properties props = new Properties();
11        props.put(StreamsConfig.APPLICATION_ID_CONFIG, "upper-case-app");
12        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
13        props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
14        props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
15
16        StreamsBuilder builder = new StreamsBuilder();
17        KStream<String, String> input = builder.stream("input-topic");
18
19        input
20            .mapValues(value -> value.toUpperCase())
21            .to("output-topic");
22
23        KafkaStreams streams = new KafkaStreams(builder.build(), props);
24        streams.start();
25
26        Runtime.getRuntime().addShutdownHook(new Thread(streams::close));
27    }
28}

The to("output-topic") call is the answer to the title question. It creates the sink node that writes the stream records into that topic.

Use Explicit Serdes When The Output Type Changes

Default serdes are fine when both the input and output use the same key and value types. If the output changes type, specify the output serdes explicitly.

1import org.apache.kafka.streams.kstream.Produced;
2
3input
4    .mapValues(value -> value.length())
5    .to("length-topic", Produced.with(Serdes.String(), Serdes.Integer()));

This matters because Kafka Streams needs to know how to serialize the outgoing key and value before writing them to the sink topic.

If you skip the explicit Produced.with(...) here, the application may fail at runtime or serialize with the wrong defaults.

Writing Derived Streams Is Still Just Writing To A Topic

More complex topologies still end with the same sink concept. You can filter, branch, group, aggregate, or join records before writing them out.

builder.stream("orders")
    .filter((key, value) -> value.contains("PAID"))
    .to("paid-orders");

From the topology perspective, the only difference is what happens before the sink. The actual write step is still to(...).

If you are working with a KTable, remember that tables are changelog-style abstractions. Converting them to a stream before writing is common:

builder.table("input-table")
    .toStream()
    .to("table-updates");

Think About Topic Creation And Semantics

Kafka Streams can write to a topic that already exists, and in many environments that is the normal setup. If the topic does not exist, whether it is created automatically depends on broker settings and operational policy.

More importantly, think about what the output topic represents. Is it an event stream, a filtered subset, a normalized topic, or a changelog-style derived feed? Clear topic semantics matter more than the single line of code that writes the records.

It is also worth thinking about the output key. The record key influences partitioning and downstream grouping behavior, so writing to a topic is not only about the value payload.

Common Pitfalls

• Forgetting that to(...) writes with serdes, so output types must match configured serializers.
• Relying on default serdes after changing the value type in a transformation.
• Treating KTable output exactly like a raw event stream without thinking about changelog semantics.
• Writing to a topic name that does not exist when the environment does not auto-create topics.
• Focusing only on the sink line and not on the meaning of the output topic contract.

Summary

• In Kafka Streams, you write to a topic with to(...) on a KStream.
• Use Produced.with(...) when the output key or value type differs from the defaults.
• Complex topologies still end in the same sink pattern: transform first, then write.
• Make sure the topic contract and serdes are correct, not just the topic name.