Hubspot Software Engineer Interview Questions

The assessment was divided into four parts, each building upon the previous one. The question I encountered was about in-memory cache, which is common knowledge online. Parts 1-3 of the in-memory cach

Four levels, design a file system (not the bank question). It only passed with a score of 480. Add file, Top n files, Merge account. There were three sub-questions in total; the last one had a bug and

I read everyone's interview experiences before and encountered the same questions, but I also made a lot of mistakes. This time, I'm giving back to the community and summarizing the questions for futu

I got a referral for HubSpot's Online Assessment (OA), a 90-minute codesignal. It wasn't too difficult, but the time was very tight. There were four levels, each worth 250 points, requiring a total of

I have final interview upcoming this Thursday. Can any one give me some advices or what to expect from their system design

Hello everyone! I'm curious about what's your "go to strategy" when it comes to integrating an external CRM (like Hubspot) into your own services/apps? Say, you have built a system where you want to p

LeetCode #277: Find the Celebrity. Difficulty: Medium. Topics: Two Pointers, Graph Theory, Interactive. Asked at Hubspot in the last 6 months.

LeetCode #2043: Simple Bank System. Difficulty: Medium. Topics: Array, Hash Table, Design, Simulation. Asked at Hubspot in the last 6 months.

## Problem Implement an HTTP GET request handler. Given a URL string and optional query parameters, construct and send the request, then parse and return the response body as a string. Handle redirects (up to 3 hops) and surface HTTP error codes as exceptions. ```python def http_get(url: str, params: dict = None, timeout_ms: int = 5000) -> str: ... ``` **Example:** ``` Input: url="https://api.example.com/users", params={"page": 1, "limit": 10} Output: '{"users": [...], "total": 42}' Input: url="https://api.example.com/gone" Raises: HTTPError(404, "Not Found") ``` ## Follow-ups 1. How would you add retry logic with exponential backoff for 5xx responses? 2. The API rate-limits at 100 req/min. How do you enforce that client-side across concurrent callers? 3. How would you cache GET responses with TTL invalidation? 4. What changes if you need to stream a large response body instead of buffering it?

## Problem You are given the following JavaScript snippets. For each one, state what it prints and explain why. **Snippet A:** ```js for (var i = 0; i < 3; i++) { setTimeout(() => console.log(i), 0); } ``` **Snippet B:** ```js for (let i = 0; i < 3; i++) { setTimeout(() => console.log(i), 0); } ``` **Snippet C:** ```js function makeAdder(x) { return function(y) { return x + y; }; } const add5 = makeAdder(5); console.log(add5(3)); console.log(add5(10)); ``` **Expected Output:** ``` Snippet A: 3 3 3 Snippet B: 0 1 2 Snippet C: 8 15 ``` Now write a function `once(fn)` that returns a wrapper that calls `fn` at most one time. Subsequent calls return the result of the first call. ## Follow-ups 1. How does `var` scoping differ from `let` in loop bodies? 2. Implement `memoize(fn)` using a closure. 3. What is the difference between `.call`, `.apply`, and `.bind`? 4. How would you debounce a function using closures?

## Problem Merge two or more arrays, possibly sorted, into a single result array. ## Likely LeetCode equivalent LC 88 (Merge Sorted Array) is closely related. ## Tags arrays, two_pointers, sorting

## Problem Given a string `s` and an integer `k`, return the substring of length exactly `k` that appears most frequently. If there is a tie, return the lexicographically smallest one. ```python def most_frequent_substring(s: str, k: int) -> str: ... ``` **Example:** ``` Input: s="abcabcabc", k=3 Output: "abc" # appears 3 times Input: s="aabaab", k=2 Output: "aa" # appears 2 times; "aa" < "ab" lexicographically Input: s="abcd", k=5 Output: "" # no valid substring ``` ## Approach Slide a window of size `k` across `s`, counting occurrences in a hash map. Track the max frequency and apply the lexicographic tiebreak in a single pass. Time: O(n*k) naive, O(n) with rolling hash. ## Follow-ups 1. How would you handle the case where `k` equals `len(s)`? 2. Extend to return the top-3 most frequent substrings in order. 3. What data structure would you use if the string is streamed and you need a running answer? 4. How does a rolling hash (Rabin-Karp) improve time complexity here?