Pletor Engineering
Sharing the engineering experience we build into our products.
We turn backend, observability, infrastructure, and operational lessons into practical notes that stay easy to read.
Latest Posts
The front page highlights practical engineering posts with code, configuration, and operating criteria.
Even When AI Writes the Code, Software Still Needs Revision
Why usable applications still require domain understanding, review, and repeated refinement in the age of vibe coding.
The Kafka Partition Looks Fine, but the Disk Is Full
Kafka 4.3 adds Partition Size Percentage metrics for retention pressure, but Kafka operators still need physical free-space monitoring for log.dirs.
AI Learned Code, but Software Learns in Operation
AI can absorb enormous written knowledge, but usable software improves through running instances, operational feedback, and production reality.
Kafka Streams After 4.2: Two Changes That Make Failures Less Painful
Kafka Streams operations often hurt around bad records and rebalances. This post explains how DLQ support and the Streams Rebalance Protocol change the operating model after Kafka 4.2.
Before Removing a Kafka Broker, Cordon First
Apache Kafka 4.3 introduced cordoned.log.dirs. This post explains what it means, how to use it, and why disk or broker decommissioning should start by blocking new replica placement.
Kafka 4.0 Consumer Rebalance: Coordination Moves to the Broker
Apache Kafka 4.0 made the new rebalance protocol generally available. This post explains what changes from the old protocol, why broker-side assignment matters, and what it means operationally.
Kafka Streams and the EIP Aggregator: Finishing Is Harder Than Grouping
When implementing the EIP Aggregator pattern with Kafka Streams, the hard parts are not groupBy and aggregate. They are correlation keys, state stores, completion conditions, and late-event policy.
Why Kafka Fits Between Outbox and Inbox Patterns
This post explains why Outbox and Inbox patterns matter in asynchronous MSA flows, and why Kafka is a strong fit as the message path between them.
Trace Should Not Break When Kafka Is in the Middle
When Kafka sits inside an MSA flow, tracing does not continue automatically like synchronous HTTP calls. This post explains how to propagate trace context through Kafka headers and how to think about producer and consumer instrumentation.
Why Did Kafka OOM When Memory Was Still Available?
Kafka broker memory is not just heap and page cache. Direct buffers can fail allocation even when system memory and heap graphs still look healthy.
Why Turn Immutable YAML Logs into Full Objects?
A practical look at why stream/event-based YAML processing can be a better fit than building a full DOM or object tree when high-volume YAML logs only need filtering.
Docker Compose Is Convenient. Plain .env Secrets Are Not.
Introducing Envoyage, Pletor's open source tool for reducing plaintext secret env files in Docker Compose workflows without turning every small deployment into a full secret-management project.
JVM Metrics Alone Cannot Explain a Container
Introducing Pletor node-metrics-agent, an open source JVM agent that exposes host and container node metrics through JMX and works well with Prometheus JMX exporter.
Can Kafka Client Metrics Really Close the Observability Gap?
A practical look at Kafka client telemetry from KIP-714: how it works, which metrics it can collect, how to configure it, and where the operational limits are.
The Large Payload Kafka Handles Well, and the One It Should Not Carry
Kafka is strong at high-volume event streams, but large file payloads can create storage amplification across the whole system.
The Kafka Broker Slowed Down, but Kafka Was Not the Cause
A practical incident-style walkthrough of a Kafka broker throughput drop, follower replicas falling out of ISR, and the storage path contention below the VM.
From Env to Config: The Last Mile of Container Configuration
A practical gomplate pattern for turning container environment variables into the configuration files applications actually read.
Your Kafka Looks Balanced. Your Brokers Disagree
Leader partition counts can look even while Kafka brokers carry very different network and storage load. This post explains how to read balancing through partition weight.
Where Kafka's Disk Is Going: Object Storage and the New Streaming Layer
A practical look at WarpStream, AutoMQ, Apache Fluss, and Kafka Diskless Topics as the Kafka ecosystem moves durable storage away from broker-local disks.
Consumer Groups Are Not Queues: What Kafka Share Groups Change
Why Kafka Share Groups were added, how they differ from traditional Consumer Groups, and when to use them.
Run Konduo Community with Docker Compose in 10 Minutes
Start Konduo Community with Docker Compose and try a local operations stack for Redis, PostgreSQL, Kafka, and other managed targets with the optional manual, Prometheus, and first login.
Five Roles Redis Plays in AI Applications
A practical look at how Redis supports AI applications as a cache, session store, retrieval helper, async work layer, and operational control plane.
Consumer Lag Is Not a Health Score: Thinking in Kafka Consuming Pressure
A practical way to read Kafka Consumer Lag together with producer rate and consumer group capacity instead of treating lag as an absolute health signal.
Not Every Consumer Group Consumes: How Kafka Nodes Find Each Other
A practical look at how Kafka Connect and Schema Registry use Kafka group coordination for membership, leader election, and distributed work.
When Logging Becomes the Bottleneck: Keeping Heavy Appender Work Off the Request Path
A practical guide to Log4j2 Custom Appenders through hot-path protection, bounded queues, AsyncAppender, throttling, and operational trade-offs.
Still Using Redis Only as a Cache? A Practical Look at Redis Streams
A practical look at Redis Streams as an append-only event log with consumer groups, pending messages, acknowledgements, and lightweight event processing.
Tags
Tags help readers find technical topics and operational lessons quickly.