6Sense Senior Software Engineer | AUG 2026 | Bangalore

6Sense SSE Interview Experience

Below is the interview experience with 6Sense for the SSE role.

---

Round 1 (DSA & Coding)

Problem Statement: Boat Connections

You are given two rows of boats anchored at fixed positions:

Row A: [2, 5, 6, 7, 8]
Row B: [5, 6, 7, 8]

You want to connect boats from Row A to boats in Row B using ropes, following these rules:

• You may draw a rope between boat A[i] and boat B[j] only if they have the same number.
• A boat can be used in at most one rope.
• The ropes must not cross - meaning if you connect A[i] to B[j], then every future rope must connect some A[i'] to B[j'] where i' > i and j' > j.

Return the maximum number of ropes you can draw.

Example

Row A: 2  5  6  7  8
Row B:    5  6  7  8

Connecting 5-5, 6-6, 7-7, 8-8 gives 4 non‑crossing ropes - this is the maximum.

Output: 4

Solution

Had a good discussion on the approach, and the interviewer gave me hints, and found that this is a variant of LIS - was able to solve this problem.

Follow‑up Question: What if Row A is not sorted?

Was able to come up with a top‑down approach where you can pick a boat in Row A, vs not picking a boat in Row A, then return the max answer.

import java.util.*;

class Solution {
    public int maxUncrossedLines(int[] rowA, int[] rowB) {
        // map each value in Row B to its index (works because rowB has distinct/sorted values)
        Map<Integer, Integer> posInB = new HashMap<>();
        for (int idx = 0; idx < rowB.length; idx++) {
            posInB.put(rowB[idx], idx);
        }

        Integer[][] memo = new Integer[rowA.length][rowB.length + 1];
        return solve(rowA, rowB, 0, 0, posInB, memo);
    }

    // i = pointer in rowA, j = smallest usable index in rowB (boats before j are "used up")
    private int solve(int[] rowA, int[] rowB, int i, int j,
                       Map<Integer, Integer> posInB, Integer[][] memo) {

        if (i == rowA.length || j == rowB.length) {
            return 0;
        }

        if (memo[i][j] != null) {
            return memo[i][j];
        }

        // Option 1: don't pick rowA[i]
        int result = solve(rowA, rowB, i + 1, j, posInB, memo);

        // Option 2: pick rowA[i] if it exists somewhere in rowB at index >= j
        Integer bIndex = posInB.get(rowA[i]);
        if (bIndex != null && bIndex >= j) {
            result = Math.max(result, 1 + solve(rowA, rowB, i + 1, bIndex + 1, posInB, memo));
        }

        memo[i][j] = result;
        return result;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] rowA = {2, 5, 6, 7, 8};
        int[] rowB = {5, 6, 7, 8};
        System.out.println(sol.maxUncrossedLines(rowA, rowB)); // 4
    }
}

Similar LeetCode problem: Uncrossed Lines

---

Round 2 (Bug Fixing Round)

The interviewer was friendly, gave me a piece of code and asked to go over scenarios one by one and fix if you see any issue. Complete fixed code as below:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/*
Problem Statement

You are building a notification routing system for a SaaS platform. The system receives notification requests and routes them to appropriate channels (Email, SMS, Slack, Webhook) based on user preferences and business rules.


Business Rules

Rule 1 - (Channel Validation)

Only notifications for enabled channels should be processed. Disabled channels must be skipped entirely.


Rule 2 - (Priority Handling)

Notifications have priority levels: `CRITICAL`, `HIGH`, `NORMAL`, `LOW`.

`CRITICAL` or `HIGH` must be sent to ALL enabled channels for that user.

`NORMAL` or `LOW` should respect user's preferred channels only.


Rule 3 - (Rate Limiting)

Each channel has a rate limit per user per hour:

Email: 10 messages/hour

SMS: 5 messages/hour 

Slack: 20 messages/hour

Webhook: 50 messages/hour

If a channel exceeds its limit, that specific channel should be skipped (not the entire notification).


Rule 4 - (Fallback Logic)

If ALL preferred channels are unavailable (disabled or rate‑limited) for a `NORMAL` or `LOW` priority notification, fall back to Email (if enabled and not rate‑limited).


Rule 5 - (Deduplication)

If the same notification (same userId + messageId) is sent within 5 minutes, it should be rejected entirely.


Rule 6 - (Empty Notification Handling)

If userId is null/empty or message content is null/empty, reject the notification.

 */

class NotificationRequest {
    String userId;
    String messageId;
    String content;
    Priority priority;
    long timestamp;

    public NotificationRequest(String userId, String messageId, String content,
                               Priority priority, long timestamp) {
        this.userId = userId;
        this.messageId = messageId;
        this.content = content;
        this.priority = priority;
        this.timestamp = timestamp;
    }
}

class UserPreferences {
    String userId;
    // EMAIl
    Set<Channel> preferredChannels;
    // SMS - TRUE, SLACK- FALSE
    Map<Channel, Boolean> channelEnabled;

    public UserPreferences(String userId, Set<Channel> preferredChannels,
                           Map<Channel, Boolean> channelEnabled) {
        this.userId = userId;
        this.preferredChannels = preferredChannels;
        this.channelEnabled = channelEnabled;
    }
}

class RoutingResult {
    boolean accepted;
    Set<Channel> routedChannels;
    String rejectionReason;
}

enum Priority {
    CRITICAL, HIGH, NORMAL, LOW
}

// 1 -> reject
//
enum Channel {
    EMAIL, SMS, SLACK, WEBHOOK
}

/*
1. multi channel, multi
 */
public class NotificationRouter {

    private static final Map<Channel, Integer> RATE_LIMITS = Map.of(
            Channel.EMAIL, 10,
            Channel.SMS, 5,
            Channel.SLACK, 20,
            Channel.WEBHOOK, 50
    );

    // Tracks message count per user per channel (simplified - assume hourly reset)
    private Map<String, Map<Channel, Integer>> rateLimitTracker = new HashMap<>();

    // Tracks recent notifications for deduplication
    private Map<String, Long> recentNotifications = new HashMap<>();

    public RoutingResult routeNotification(NotificationRequest request, UserPreferences prefs) {

        RoutingResult result = new RoutingResult();
        result.routedChannels = new HashSet<>();
        // validate request
        if (request.userId.isEmpty() || request.content.isEmpty()) {
            result.accepted = false;
            result.rejectionReason = "user id is empty or content is empty";
            return result;
        }
        // Check for duplicates
        String dedupKey = request.userId + ":" + request.messageId;
        if (recentNotifications.containsKey(dedupKey)) {
            long lastSent = recentNotifications.get(dedupKey);
            if (request.timestamp - lastSent <= 300000) {
                result.accepted = false;
                result.rejectionReason = "Duplicate notification";
                return result;
            }
        }

        Set<Channel> targetChannels = new HashSet<>();

        // Determine target channels based on priority
        if (request.priority == Priority.CRITICAL || request.priority == Priority.HIGH) {
            // we should add a for loop, send only enabled ones
            targetChannels.addAll(prefs.channelEnabled.keySet());
        } else {
            targetChannels = prefs.preferredChannels;
        }

        // Route to each target channel
        for (Channel channel : targetChannels) {
            if (prefs.channelEnabled.get(channel)) {
                if (isWithinRateLimit(request.userId, channel)) {
                    result.routedChannels.add(channel);
                    incrementRateLimit(request.userId, channel);
                }
            }
        }

        // Fallback logic
        // no channel present (NORMAL oR LOW) - EMAIl (if valid)
        if (result.routedChannels.isEmpty()) {
            if (request.priority == Priority.LOW || request.priority == Priority.HIGH) {
                if (prefs.channelEnabled.get(Channel.EMAIL) &&
                        isWithinRateLimit(request.userId, Channel.EMAIL)) {
                    result.routedChannels.add(Channel.EMAIL);
                    incrementRateLimit(request.userId, Channel.EMAIL);
                }
            }
        }

        result.accepted = !result.routedChannels.isEmpty();
        if (!result.accepted) {
            result.rejectionReason = "All channels unavailable";
            return result;
        }
        recentNotifications.put(dedupKey, request.timestamp);
        return result;
    }

    private boolean isWithinRateLimit(String userId, Channel channel) {
        // email, 5
        Map<Channel, Integer> userLimits = rateLimitTracker.get(userId);
        if (userLimits == null) {
            return true;
        }
        Integer count = userLimits.get(channel);
        return count == null || count < RATE_LIMITS.get(channel);
    }

    private void incrementRateLimit(String userId, Channel channel) {
        rateLimitTracker.putIfAbsent(userId, new HashMap<>());
        Map<Channel, Integer> userLimits = rateLimitTracker.get(userId);
        userLimits.put(channel, userLimits.getOrDefault(channel, 0) + 1);
    }
}

---

Round 3 (HLD)

Design a large‑scale news aggregation platform similar to Google News. The system continuously ingests articles from thousands of publishers (via RSS feeds, partner APIs, and web crawlers), and presents users with a fresh, organized feed of the day's news. Articles covering the same real‑world event must be grouped together into a single "story," deduplicated, and categorized (e.g., Tech, Sports, Politics). The feed should feel fresh (breaking news surfacing within minutes), be personalized to a user's interests, and load with low latency for millions of daily users. Walk me through the end‑to‑end architecture, the key data flows, and the major trade‑offs you'd make.

This round went well, went ahead and designed end to end system, the interviewer was more interested in the HLD flow along with other edge case scenarios, like how to solve breaking news in real‑time. We jumped directly into the design rather than API, estimates etc. which was good.

Talked about the two flows in depth:

1. Feed ingestion service and populating in a Redis sorted set for feed generation, so it's fan‑out on write.
2. Feed Retrieval service flow.
3. And other edge case scenarios.

This round went well overall.

---

Round 4 (LLD)

This round was supposed to be a LLD round, but we ended up discussing my projects in depth, and the last 10 mins was reserved for LLD and asked about my current project structure etc. The interviewer was not much friendly and it didn't go well.

---

Overall experience was good, hope this helps the community.