Dakshin

Salesforce SMTS Interview Experience

Sat, 26 Sep 2026 00:00:00 +0000

I recently cleared the interview process for a Senior Member of Technical Staff (SMTS) role at Salesforce. To help others preparing for senior engineering roles, I’m sharing my complete experience here.

The loop heavily evaluated DSA, Low-Level Design (LLD), High-Level Design (HLD), and deep-dives into my past work experiences. Overall, the rounds were rigorous but collaborative, practical, and grounded in real-world problem-solving.

The Interview Loop

The entire process was fast-paced, taking around 2–3 weeks from start to finish. The loop was a mix of virtual and on-site stages, and each round was an elimination round.

How Kafka and Nginx Move Data Faster: The Magic of Zero Copy

Tue, 19 May 2026 00:00:00 +0000

Ever wonder how tools like Kafka, Nginx, Netty manage to saturate a 10Gbps network link while barely breaking a sweat on CPU usage?

It’s not just efficient indexing. It’s because they understand a fundamental truth: The fastest way to move data is to never touch it.

The Slow Way: Traditional Copy

In a standard Java application, moving a file to a socket looks like this:

Disk → Kernel Buffer: The OS reads data from the disk.
Kernel Buffer → User Buffer: The OS copies data into your application’s memory (the byte[] array).
User Buffer → Socket Buffer: Your app writes that array back to the OS.
Socket Buffer → NIC: The OS moves it to the network card.

4 context switches

Stop Debugging in the Dark: The "Day Zero" Observability Checklist

Mon, 20 Apr 2026 00:00:00 +0000

I recently read a fascinating post by Picnic Engineering titled “Bringing Observability to the Workstation.” It’s a great reminder that “clean code” isn’t enough if you have zero visibility into your production environment.

In our fast-paced industry, we often prioritize shipping features over building insights. We tell ourselves we’ll add monitoring “later,” only to find ourselves blind when the first production incident occurs.

Waiting for a bug to happen before setting up observability is a high-stakes gamble. It is always better to establish a “bare minimum” layer from the start.

Kafka Under the Hood: A Visual Guide to KRaft and Internal Architecture (2026)

Sun, 15 Mar 2026 00:00:00 +0000

Stop configuring ZooKeeper. Seriously. In 2026, Apache Kafka is a leaner, meaner beast, managed entirely within its own ecosystem via KRaft. But while the architecture has simplified on the surface, the ‘under-the-hood’ mechanics of how the Control Plane (the brains) and the Data Plane (the muscle) actually collaborate are more critical than ever.

The diagram below is your modern source of truth for the Kafka lifecycle.

Under the Hood: Redis Enterprise Cluster

Tue, 10 Feb 2026 00:00:00 +0000

The power of Redis lies in its simplicity. One thread, one event loop, zero locks.

Single-threaded execution eliminates the “lock contention” that slows down traditional databases.
Limitation: A single process can only utilise one CPU core. On a 64-core server, 98% of your hardware sits idle.

Redis Core Design

To scale, Redis Enterprise doesn’t make the engine “bigger”; it makes the fleet smarter.

Key Design Decisions

1. One Core to Many (Multi-Tenancy)

Instead of one massive process, Enterprise runs multiple Redis Cores (shards) on a single node.

Apache Kafka - Achieving Exactly-Once Semantics (EOS)

Fri, 14 Nov 2025 00:00:00 +0000

In distributed systems, message delivery guarantees are one of the most critical design considerations. Every pipeline must answer a deceptively simple question: how many times will this message be processed?

Traditionally, systems have offered two guarantees:

• At-most-once delivery: Messages are processed zero or one time. This avoids duplicates but risks data loss if failures occur.
• At-least-once delivery: Messages are processed one or more times. This ensures reliability but introduces duplicates that downstream systems must handle.

In domains like payments, fraud detection, and compliance auditing, duplicates or lost events can have severe consequences.

PostgreSQL Under Load - Part 2: Vacuum, Analyze, and Index

Fri, 10 Oct 2025 00:00:00 +0000

In Part 1, we tackled partitioning — the first step to keeping Postgres performant under heavy write loads. Partitioning solved routing, not cleanup.

Postgres uses MVCC (Multi-Version Concurrency Control) to handle concurrent reads and writes. It’s brilliant, but it comes with a caveat: every update leaves behind dead tuples, every delete lingers until vacuumed, and every index quietly bloats over time.

This post dives into the cleanup side of scaling:

PostgreSQL Under Load - Part 1: Partition Like a Pro

Sat, 20 Sep 2025 00:00:00 +0000

This post is split into two parts for brevity.

Part 1: Partition like a Pro
Part 2: Vacuum, Analyze and Index

Let’s start by setting the scene.

You’ve got a backend service humming in production - maybe its ingesting user events, transaction logs, or IoT metrics. Everything’s smooth until one day, your dashboards light up:

• Insert latency spikes from 10ms to 500ms.
• CPU usage climbs, even though your queries haven’t changes.
• Auto-vacuum falls behind, and your disk usage balloons overnight.
• A simple SELECT query takes 3 seconds. Three. Whole. Seconds.

You check the table: 400 million rows ; No analytics - just trying to write fast and read fresh. But Postgres is groaning under the weight of your workload. It’s a write-heavy, recent-data problem – and Postgres can absolutely handle it, only if you treat it right.

Apache Kafka - The Architecture to Handle Billions of Events Per Day

Wed, 20 Aug 2025 00:00:00 +0000

The modern digital world operates on an unprecedented volume of data. Every click, transaction, sensor reading, and user interaction is an event, and the systems designed to process them must handle this stream in real-time, reliably, and at massive scale.

The Scale Challenge

• LinkedIn, Kafka’s creator, processes over 7 trillion messages per day.
• Uber handles trillions of messages and multiple petabytes of data daily, from calculating ETAs to driver-rider matching.
• FinTech companies handle over a billion events every day to process transactions and real-time monitoring. In this deep dive, we will move past the basic definitions of Kafka and explore the specific architectural patterns and configuration tuning strategies that allow Kafka to manage billions of events per day.

The Three Pillars of Kafka Scalability

Kafka’s remarkable scaling ability is rooted in a design philosophy that treats data not as records in a database, but as an immutable, distributed commit log. This simple, yet powerful, concept allows it to sustain immense throughput.

Inside the JVM - Profiling & Diagnosing Memory Leaks in Java

Fri, 15 Aug 2025 00:00:00 +0000

A few months back, while working on a backend service that used Drools for rule evaluation, I noticed something odd - JVM heap usage kept climbing, GC metrics were off, and eventually, the service crashed with an OutOfMemoryError. Profiling the JVM with VisualVM and Java Flight Recorder, and analyzing a heap dump revealed a memory leak tied to rule engine objects.

The root cause? A Drool’s Session resource that wasn’t closed properly. That one oversight let to retained references, bloated heap and a production outage.