
I just wrapped up and passed my Goldman Sachs Software Engineer interview in 2026. The process tested both behavioral and technical questions, especially through the HireVue interview process and later coding rounds.
What surprised me most was how much the interview focused on clarity, not just correctness. It’s not only about solving problems, but explaining them well under pressure.
I am really grateful to Linkjob.ai for helping me pass my interview, and that’s also why I’m sharing here my entire interview experience and the questions I encountered. Having an undetectable live AI interview assistant during the interview indeed provides a significant edge.

I realized early that behavioral questions matter just as much as coding. I spent time refining my stories, which really paid off during later rounds.
The HireVue interview process felt awkward at first, but practicing virtual answering tips helped me sound more natural and confident.
Coding questions were mostly LeetCode-style, but interviewers often added follow-ups. Solving the base problem wasn’t enough—you had to adapt quickly.
Time management was critical, especially in the OA. I didn’t aim for perfection, I aimed to maximize score under constraints.
Preparation strategy mattered more than volume. I focused on patterns instead of random practice, which helped me recognize problems faster.
For SWE roles, most of the technical focus was on coding and problem-solving.
But I did notice that some roles (like risk or analytics) leaned more into domain knowledge. Even in engineering interviews, they sometimes asked about trade-offs or real-world constraints. So it wasn’t just “solve the problem,” but also “how would this work in production?”
These questions focus heavily on financial fundamentals and valuation logic.
You’re expected to clearly explain concepts like the three financial statements, DCF, WACC, and LBO, often under follow-up pressure.
Interviewers care less about memorization and more about whether you understand how the pieces connect in real-world deals.
This section tests your market awareness and ability to think on your feet.
Common questions include pitching a stock, discussing macro trends, and explaining recent market movements.
You don’t need to be “right,” but you must have a clear investment framework and defend your view logically.
These questions are more focused on your personal investment thinking.
You may be asked about your portfolio, investment philosophy, or how you evaluate companies.
Strong answers usually combine qualitative judgment (like management and industry) with quantitative reasoning (like valuation).
For engineering roles, the focus is on coding, system design, and project discussion.
Expect LeetCode-style problems, along with questions about scalability, trade-offs, and real-world implementation.
You’ll also need to explain why you chose Goldman Sachs over a traditional tech company.
I got pretty standard behavioral questions, but they weren’t as easy as they sound.
They really pushed me to go beyond surface-level answers.
For example, when I talked about a project I was proud of, they kept asking follow-ups like what impact it had and what I would do differently.
It felt more like a conversation than a checklist.
I also got conflict-related questions. They wanted to see if I could handle disagreements without escalating things, especially in a team setting.
The OA was the first real technical filter, and I took the test of Goldman Sachs on HackerRank OA.
I got two coding questions in a timed environment, and both were pretty implementation-heavy.
Coding Question 1: Transaction Segments
Problem Summary:
Given an array transactionValues, count the number of subarrays of length k that are strictly increasing.
My Approach
I used a sliding window idea. Instead of checking every subarray from scratch, I tracked how long the current increasing sequence was.
💻 Code (Python)
def countIncreasingSubarrays(nums, k):
n = len(nums)
count = 0
length = 1 # length of current increasing sequence
for i in range(1, n):
if nums[i] > nums[i - 1]:
length += 1
else:
length = 1
if length >= k:
count += 1
return countCoding Question 2: Efficient Tasks Allocation
Problem Summary:
Distribute tasks into 3 groups. From each group pick one value to minimize:
|d1 - d2| + |d2 - d3|Then maximize this minimum across all distributions.
My Approach
This problem was much harder.
I didn’t reach a fully optimal solution, but I:
Tried greedy grouping
Explained trade-offs clearly
Focused on reasoning
💻 Code (Simplified Approach)
import itertools
def max_min_value(difficulty):
n = len(difficulty)
best = float('-inf')
# Try all partitions (only feasible for small n)
for split in itertools.product(range(3), repeat=n):
groups = {0: [], 1: [], 2: []}
for i in range(n):
groups[split[i]].append(difficulty[i])
if not all(groups.values()):
continue
min_val = float('inf')
for d1 in groups[0]:
for d2 in groups[1]:
for d3 in groups[2]:
val = abs(d1 - d2) + abs(d2 - d3)
min_val = min(min_val, val)
best = max(best, min_val)
return bestThis round was more conversational. I was coding live while explaining everything step by step. Before my interview, I also collected some real Goldman Sachs CoderPad questions from other candidates.
Coding Question 1: First Non-Repeating Character
💻 Code
def firstUniqChar(s):
from collections import Counter
count = Counter(s)
for c in s:
if count[c] == 1:
return c
return NoneCoding Question 2: Highest Average Score
💻 Code
from collections import defaultdict
def highestAverage(records):
scores = defaultdict(list)
for name, score in records:
scores[name].append(score)
max_avg = float('-inf')
for name in scores:
avg = sum(scores[name]) / len(scores[name])
max_avg = max(max_avg, avg)
return max_avgI also got two behavioral questions:
“My manager assigned me as team lead, but a teammate disagreed. What would I do?”
“My manager asked for sensitive data from my project. How would I respond?”
These tested conflict resolution and ethics.
To tell the truth, one of them actually caught me off guard. Many thanks to LinkjobAI for helping me quickly structure my response, I didn’t panic.

Undetectable Coding Interview Assistant
This was the final stage and definitely the most intense.
Two back-to-back rounds, each with coding + behavioral.
💻 Code
def lengthOfLongestSubstring(s):
char_set = set()
left = 0
max_len = 0
for right in range(len(s)):
while s[right] in char_set:
char_set.remove(s[left])
left += 1
char_set.add(s[right])
max_len = max(max_len, right - left + 1)
return max_lenFollow-up
Return the actual substring, not just length.
def longestSubstring(s):
char_set = set()
left = 0
max_len = 0
result = ""
for right in range(len(s)):
while s[right] in char_set:
char_set.remove(s[left])
left += 1
char_set.add(s[right])
if right - left + 1 > max_len:
max_len = right - left + 1
result = s[left:right+1]
return result1. Group Anagrams
from collections import defaultdict
def groupAnagrams(strs):
groups = defaultdict(list)
for s in strs:
key = tuple(sorted(s))
groups[key].append(s)
return list(groups.values())2. Grid Movement Simulation
def move(commands):
x, y = 0, 0
for c in commands:
if c == 'U':
y += 1
elif c == 'D':
y -= 1
elif c == 'L':
x -= 1
elif c == 'R':
x += 1
return (x, y)The problems themselves weren’t crazy hard. But the interviewer kept modifying requirements. For example:
Handle uppercase + lowercase
Add constraints mid-way
Ask for complexity analysis
Before my interviews, I spent some time understanding what Goldman Sachs actually values. A few things kept coming up: teamwork, integrity, and a strong sense of ownership.
They clearly expect people to communicate well and take responsibility, especially in high-pressure situations. It’s not just about being technically strong—you also need to work effectively with others.
When I prepared my behavioral answers, I made sure my examples showed these qualities naturally. That made my responses feel more aligned with what they were looking for, instead of sounding generic.
This helped me avoid over-preparing irrelevant topics. Different teams expect very different things. For engineering roles, I focused on coding and system thinking. For other roles, I would’ve prioritized domain knowledge more.
Practicing alone wasn’t enough. I needed feedback on how I explained things. Once I started doing mock interviews, I realized I was skipping steps in my explanations. Fixing that made a big difference.
This mattered more than I expected. Even for technical roles, awareness of markets or tech trends helped. I didn’t go too deep, but I made sure I could talk about something recent confidently.

I didn’t rigidly follow STAR, but I kept my answers structured. That made it easier for interviewers to follow. Whenever I felt myself rambling, I reset and focused on the outcome.
There were definitely moments I didn’t know the answer. Instead of freezing, I talked through my thought process. Interestingly, that often led the interviewer to give hints. So communication actually became part of the solution.
One mistake I made early was over-optimizing too soon. That cost me time during the OA. I also underestimated how much follow-ups matter. Getting the base solution isn’t enough.
In the end, consistency mattered more than brilliance. I focused on being clear, calm, and structured. Looking back, I didn’t need perfect answers. I just needed to show how I think.
I focused on common patterns like sliding window and hashmap problems. I also practiced under time pressure to simulate the real test.
I kept it simple and clean. Nothing fancy, just professional enough to not distract.
Firstly I force myself to keep clam, explain my thinking step by step, which is usually better than staying silent. After that, I turn to Linkjob AI for the hints and well-organized answers.
I used real examples with clear impact. Generic answers don’t work here.
Yes, and I made sure they were specific. It shows genuine interest.
How I Aced the Goldman Sachs Software Engineer Online Assessment in 2026
How I Passed Goldman Sachs Summer Analyst 2026 Interview
My 2026 Goldman Sachs Superday Experience and Real Questions