Morgan Stanley Interview Questions (2026): Most Asked

This opens almost every round, and the mistake is treating it as a chronological recap. Pick the two or three points on your resume that connect directly to the seat you're interviewing for and spend your time there. If you're interviewing for Sales & Trading, don't spend ninety seconds on a marketing internship from three years ago just because it's next in line. Interviewers are listening for a narrative that explains why you ended up applying to this specific division, not a list of dates.

The weak version of this answer talks about brand name and prestige. The stronger version names something specific: a deal the firm advised on, a desk's reputation within a product, a person you spoke to at an info session and what they told you about the culture on that floor. Morgan Stanley interviewers hear "I want to work at a top bank" dozens of times a cycle. What separates candidates is whether the division-specific detail sounds like it came from actual research or a conversation, not from the firm's own website copy repeated back to them.

Pick a story with real stakes, not a group project where the worst outcome was a slightly lower grade. Walk through what information you actually had, what you assumed, and how you'd have changed your approach if the assumption had been wrong. Interviewers are listening for whether you can articulate the risk you took on knowingly, since that's close to the daily reality of a trading desk or a deal team working against a deadline with partial data.

Walk through the actual criteria you used to rank the work, not just that you "prioritized effectively." Did you weigh which task had a harder external deadline, which one blocked someone else's work, which one had the higher cost if it slipped? Interviewers want to hear your reasoning process, since analyst and associate roles at the firm involve juggling requests from multiple senior people simultaneously, and the ability to triage transparently matters more than raw hours worked.

The expected solution walks the list once, keeping track of the previous node, and reversing each pointer as you go, without allocating a second list.

def reverse_list(head):
  prev = None
  current = head
  while current:
    next_node = current.next
    current.next = prev
    prev = current
    current = next_node
  return prev

Interviewers usually follow up by asking you to do the same thing recursively, and then asking which version you'd actually ship, since the recursive version risks a stack overflow on a very long list that the iterative version doesn't.

A single pass to build a frequency count, followed by a second pass over the original string in order, checking each character's count, solves this in linear time without needing to sort anything.

def first_unique_char(s):
  counts = {}
  for ch in s:
    counts[ch] = counts.get(ch, 0) + 1
  for ch in s:
    if counts[ch] == 1:
      return ch
  return None

Push opening characters onto a stack, and on a closing character, check that it matches whatever's on top of the stack before popping it. An empty stack at the end means the string is balanced.

def is_balanced(s):
  pairs = {")": "(", "]": "[", "}": "{"}
  stack = []
  for ch in s:
    if ch in "([{":
      stack.append(ch)
    elif ch in pairs:
      if not stack or stack.pop() != pairs[ch]:
        return False
  return not stack

This isn't really asking for a news recap, it's checking whether you have a standing opinion you update daily rather than one you assembled for the interview. Name the specific data point or event moving markets, then give a short, defensible view on what it means, not a hedge in every direction. Vague answers, "it's mixed" or "there are a lot of factors," read as someone who skimmed a headline an hour before walking in.

Bond prices move inversely to interest rates. A bond's coupon is fixed at issuance, so when new bonds come to market paying a higher rate, an existing bond with a lower fixed coupon becomes less attractive unless its price falls enough to make its effective yield competitive with the new rate. The longer a bond's duration, the more sensitive its price is to a given rate change, which is why long-dated bonds move more sharply than short-dated ones for the same rate shift.

A call option gives the holder the right, not the obligation, to buy an underlying asset at a set strike price, a put gives the right to sell at that strike. Pricing depends on the underlying's current price relative to the strike, time remaining until expiration, and implied volatility, since more time and more expected price movement both increase the odds the option finishes in the money, which raises its value even before you account for the direction of the underlying's move.

Comparable company analysis, precedent transactions, and discounted cash flow. Comps and precedents anchor to what the market is actually paying right now, which makes them the default weight in a live deal process where you need a defensible, market-supported number. DCF matters most when a company's near-term multiples look distorted, a temporary earnings dip, a recent one-time event, since it lets you value the business on its own projected cash flows independent of what comparable companies happen to be trading at this week.

Avoid jargon like correlation coefficients entirely. A workable version: if all your money sits in one company and something goes wrong with that company, everything you have goes wrong at the same time. Spreading money across different companies, industries, and asset types means a problem in any one area doesn't take down the whole portfolio at once. Interviewers are checking whether you can translate a technical idea into something a real client would actually retain, not whether you know the formal definition.

Treat each interview as its own reset, not a continuation. A common mistake is letting a rough technical round bleed into the next behavioral one, walking in still rattled instead of resetting. Interviewers at a superday usually don't compare notes in real time between rounds, so a weak answer in round two doesn't automatically poison round three unless you let it show on your face. Ask for thirty seconds between rounds if you need it, drink water, and treat the next interviewer as someone meeting you for the first time, because they are.

The coding bar is similar to a mid-size tech company, data structures, algorithms, sometimes a take-home or online assessment through a platform like HackerRank or Codility. What's different is the second layer of questions about risk, auditability, and why a system needs to behave predictably under regulatory scrutiny, not just perform well under load. A trading system that's fast but occasionally produces an unexplainable result is a bigger problem at a bank than at a consumer app, and interviewers will probe whether you understand that distinction, not just whether your code passes test cases.

By the time you're in a superday, pedigree got you the interview, it doesn't win you the offer. Interviewers at this stage are told to score against a specific rubric, technical competence, communication, and fit with the desk's working style, and a strong answer from a state school candidate beats a mediocre one from a target school every time I've seen it play out. The exception is entry-level analyst programs where the initial resume screen is genuinely GPA-gated, but once you're sitting across from someone, that filter has already done its job.

The version of this story that lands well ends with you raising the disagreement through a reasonable channel, not going around the person or staying silent. Explain what you disagreed about, how you framed the pushback, and what actually happened, including if you were wrong. A story where you were right and got vindicated is fine, but a story where you were wrong and updated your view without resentment often reads as more mature, because it shows you can be corrected without shutting down.

This question is fishing directly for "Put Clients First" and candidates who haven't prepared a real example often invent something thin on the spot. A strong answer names a concrete tradeoff: staying late to redo an analysis because the first version had an error that would've misled the client, or pushing back on a deadline internally to buy the client more accurate information. The specificity is what makes it believable. Vague statements about "always prioritizing the client" without a story attached tend to fall flat.

Avoid the fake-failure trap, "I worked too hard" or "I cared too much" reads as evasive to an experienced interviewer. Name an actual failure with a real consequence, then spend more time on the specific change you made afterward than on the failure itself. Interviewers use this question to gauge self-awareness under pressure, and a candidate who can describe a mistake without defensiveness usually comes across better than one with a spotless-sounding history.

This connects to "Commit to Diversity and Inclusion" but the strongest answers avoid restating the value and instead describe a specific adjustment you made, changing how you communicated with a teammate who preferred written updates over verbal check-ins, for example. Interviewers are checking whether you can adapt your own style rather than expecting everyone else to adapt to you, since global deal teams and trading desks routinely mix people across offices, time zones, and working norms.

Depth-first search with three states per node, unvisited, in the current recursion stack, and fully processed, catches a cycle the moment you revisit a node that's still in the current path. A node fully processed and later revisited from a different branch is not a cycle, which is the detail candidates most often get wrong by using a single visited set instead of tracking recursion-stack membership separately.

def has_cycle(graph):
  WHITE, GRAY, BLACK = 0, 1, 2
  color = {node: WHITE for node in graph}

  def dfs(node):
    color[node] = GRAY
    for neighbor in graph[node]:
      if color[neighbor] == GRAY:
        return True
      if color[neighbor] == WHITE and dfs(neighbor):
        return True
    color[node] = BLACK
    return False

  return any(dfs(n) for n in graph if color[n] == WHITE)

Sort by start time first, then walk the sorted list once, merging the current interval into the last one kept whenever it starts before or at the previous interval's end.

def merge_intervals(intervals):
  intervals.sort(key=lambda x: x[0])
  merged = [intervals[0]]
  for start, end in intervals[1:]:
    last_start, last_end = merged[-1]
    if start <= last_end:
      merged[-1] = (last_start, max(last_end, end))
    else:
      merged.append((start, end))
  return merged

Average case is O(1), but that guarantee depends on a well-distributed hash function and a load factor kept low enough that collisions stay rare. Worst case degrades to O(n) if many keys hash to the same bucket, which is exactly the scenario a poorly chosen hash function or an adversarial set of inputs can create. Most production hash map implementations rehash and resize once the load factor crosses a threshold specifically to keep the average case honest.

A process has its own isolated memory space, a thread shares memory with every other thread in the same process, which makes threads cheaper to create and communicate between but exposes them to the exact race conditions that a process boundary would prevent. Trading systems lean on threads for speed, low latency order handling can't afford the overhead of inter-process communication, but that speed comes with the obligation to reason carefully about which shared state actually needs a lock and which doesn't.

Latency percentiles matter more than averages here, the p99 tail latency on order acknowledgment is often the number that actually determines whether a strategy is viable, since a single slow outlier can mean a missed fill. Beyond latency, you'd want alerting on order rejection rates, any spike suggests either a bug or a connectivity issue upstream, and reconciliation checks that compare the system's internal view of open positions against an independent source of truth, since a silent mismatch there is far more dangerous than a visible crash.

Pick a company you can defend under pushback, not necessarily the flashiest name you can think of. Structure it around a thesis, why the market is mispricing it right now, what catalyst changes that, and what would make you wrong. Interviewers will push on the "what makes you wrong" part specifically, and a candidate who can't name a real risk to their own pitch usually hasn't thought about it as deeply as the confident delivery suggests.

Duration measures a bond's price sensitivity to a change in interest rates, weighted by the timing of all its cash flows, not just its final maturity date. Two bonds with the same maturity but different coupon structures can have meaningfully different durations, a zero-coupon bond has duration equal to its maturity since all the cash flow arrives at the end, while a high-coupon bond returns cash earlier and has a shorter duration than its stated maturity would suggest.

Prices move on the gap between actual results and what was already priced in, not the gap between results and the published consensus estimate. If the market had quietly built in expectations well above consensus, a beat against consensus can still be a miss against what investors were actually positioned for. Forward guidance often matters more than the quarter that just closed, a beat with cautious guidance for the next quarter can still send the stock down if guidance is what the market was really watching.

The yield curve plots interest rates across bonds of different maturities from the same issuer, normally upward sloping since investors demand more yield for locking up money longer. An inversion, short-term yields exceeding long-term yields, has historically preceded recessions in the U.S., because it reflects markets pricing in future rate cuts in response to expected economic weakness. It's a signal, not a guarantee, and the lag between an inversion and an actual downturn has varied significantly across past cycles.

Project a company's unlevered free cash flow for a forecast period, usually five to ten years, discount each year's cash flow back to present value using the weighted average cost of capital, then add a terminal value representing everything beyond the forecast period, also discounted back to today. The terminal value, whether calculated with a perpetuity growth rate or an exit multiple, typically makes up the majority of the total valuation, which is exactly why small changes in the terminal growth assumption or discount rate swing the output so much.

Enterprise value represents the value of the entire operating business, independent of how it's financed, equity value is what's left over for shareholders after subtracting net debt. Enterprise value is the right basis for comparing companies with different capital structures, since it strips out the effect of debt versus equity financing choices, which is why revenue and EBITDA multiples typically use enterprise value in the numerator. Equity value is what you'd actually pay to buy all the outstanding shares, and it's the basis for P/E ratios, since earnings per share already reflects interest expense on the company's actual debt load.

Net income includes non-cash items and accrual-based revenue recognition that don't necessarily correspond to cash actually collected in the period. A company can book substantial revenue on credit sales that haven't been collected yet, tying up cash in accounts receivable, or it can be investing heavily in capital expenditures or building inventory, both of which consume cash without reducing net income the same way. This is exactly why a cash flow statement matters as much as an income statement, since a profitable company on paper can still face a genuine liquidity crunch if its cash conversion cycle is stretched too far.

The expected value per flip is $50, positive, so a single flip is worth taking on expected value alone. The more interesting part of the question is variance and bankroll, a string of tails in a row can wipe out a small bankroll even with positive expected value, so the honest answer names both the expected value calculation and the practical constraint that expected value alone doesn't tell you whether it's a good bet for a specific bankroll size, especially if you can't play it enough times for the law of large numbers to smooth out the variance.

Value at Risk estimates the maximum loss a portfolio is expected to experience over a given time horizon at a given confidence level, a one-day 95% VaR of $10 million means you'd expect to lose more than $10 million on only 5% of trading days under normal conditions. Its biggest limitation is that it says nothing about how bad losses get on the days that fall outside that confidence interval, the tail. A portfolio can have a perfectly reasonable-looking VaR number and still be exposed to a catastrophic loss in the 5% of scenarios the metric doesn't describe, which is why risk desks pair VaR with stress tests and scenario analysis rather than relying on it alone.

Regulatory capital exists to absorb unexpected losses without the bank becoming insolvent or needing a government bailout, which is the core lesson regulators drew from the 2008 financial crisis and encoded into frameworks like Basel III. The tradeoff is that capital held in reserve isn't capital deployed into higher-return lending or trading activity, so a bank holding well above the regulatory minimum is, in a sense, choosing safety over return on equity. Getting that balance right, enough of a buffer to survive a real shock without holding so much that returns suffer, is a genuinely contested question among bank management teams and regulators, not a solved one.

Start by acknowledging the fear is real before trying to talk them out of the decision, dismissing the emotion first tends to make a client feel unheard and dig in harder. Then walk through what selling now actually locks in, a temporary paper loss becomes a permanent, realized one, and ask what's changed about their actual long-term goals versus what's changed about their short-term feelings. The point isn't to talk every client out of every decision regardless of circumstances, sometimes selling is genuinely the right call, it's to make sure the decision is being made on the plan, not on the fear.

A traditional IRA gives a tax deduction on contributions now, with withdrawals taxed as income in retirement. A Roth IRA offers no upfront deduction, contributions are made with after-tax dollars, but qualified withdrawals in retirement are entirely tax-free. The deciding factor usually comes down to whether the client expects to be in a higher or lower tax bracket in retirement than they are now, someone early in their career expecting significant income growth often benefits more from a Roth, while someone at peak earnings years nearing retirement often benefits more from the traditional deduction today.

Lead with transparency about fees and how you're actually compensated before the client has to ask, since unprompted disclosure signals you're not hiding anything. Then focus early conversations on understanding the client's actual goals and risk tolerance rather than pitching specific products in the first meeting, since a skeptical client is watching for whether you're listening or just selling. Trust in this business is built slowly, through consistent follow-through on small commitments, more than through any single compelling pitch in an initial meeting.

This is a values question with a real institutional weight behind it, not a hypothetical. The expected answer involves raising the concern through the appropriate channel, a manager, compliance, or the firm's reporting line, rather than staying quiet to avoid conflict or handling it unilaterally outside the process. Candidates who answer "I'd confront them directly and handle it myself" without mentioning any formal escalation path usually miss what the question is actually checking for, which is whether you understand that conduct issues at a regulated financial firm go through a process, not personal judgment alone.

Sort the file externally, in chunks small enough to fit in memory, then merge the sorted chunks and scan the merged output once for adjacent duplicates. A hash-set approach only works if the whole key set fits in memory, which is exactly the assumption the question is designed to break, since a full day of trade logs at a firm this size can easily exceed a single machine's RAM. If the file lives in a distributed store already, a map-reduce style group-by-key with a count filter accomplishes the same thing without ever pulling the whole dataset onto one box.

Without a lock or an atomic operation, both threads can read the same starting value, apply their own update independently, and write back, with the second write silently overwriting the first thread's change instead of both updates applying. On an order book that means a cancelled or filled order can appear to still be live, or a quantity update can get lost entirely, and the failure doesn't throw an exception, it just produces a wrong number that looks plausible. The fix is either a lock around the critical section, a compare-and-swap operation, or restructuring the update to go through a single-threaded queue that serializes writes to that entry.

Blue-green deployment, running the new version alongside the old one and cutting traffic over once it's verified healthy, is the standard pattern, but the harder part specific to trading is state migration, in-flight orders on the old instance need to either finish processing there or transfer cleanly to the new instance without duplicating or losing them. Most firms restrict any non-emergency deployment to defined maintenance windows outside market hours specifically to avoid this problem rather than solving it live, and a candidate who suggests that as the practical answer, alongside the blue-green mechanics, usually reads as someone who's actually worked in this kind of environment.

Buying put options caps downside while keeping upside exposure, at the cost of the premium paid. A collar, buying a put and selling a call to fund it, reduces or eliminates that cost but caps upside in exchange. A short position in a correlated index or basket hedges systematic risk without touching the specific position at all, useful when you want to keep the stock-specific thesis but reduce exposure to a broader market move you're less confident about. The right answer depends on whether the goal is protecting against a specific event or reducing broad market exposure, and naming that distinction is usually more important to the interviewer than picking one instrument.

WACC weights the cost of equity and the after-tax cost of debt by each source's proportion of total capital. You use market values, not book values, because the weights are meant to reflect what it would actually cost to raise a marginal dollar of financing today, and book value of equity in particular can diverge wildly from what the market is actually pricing the company's equity at, especially for a company that's grown significantly since its equity was originally issued.

WACC = (E / (E + D)) * Cost of Equity + (D / (E + D)) * Cost of Debt * (1 - Tax Rate)

On the balance sheet, debt increases by $100, cash decreases by $100 as it's used to repurchase shares, and shareholders' equity decreases both from the reduced share count's implied value and from the retirement of treasury stock. On the income statement, the new debt adds interest expense going forward, reducing net income and therefore reducing retained earnings on the balance sheet by that after-tax interest amount each year going forward. Because share count falls, earnings per share often still rises even though total net income falls slightly, which is the entire reason companies use debt-funded buybacks in the first place, assuming the cost of debt is lower than the earnings yield on the repurchased shares.

The intuitive but wrong answer is one half. Think in terms of coins, not boxes, there are three gold coins total across the boxes, and two of those three gold coins sit in the all-gold box alongside another gold coin. So the probability the other coin is also gold is two thirds, not one half. This is a classic conditional probability trap, and interviewers use it specifically to see whether you default to gut intuition or actually work through the conditioning correctly under a little pressure.

Every state-changing event needs to be written to an append-only, immutable log before the system acts on it, not after, so a crash between the write and the action never leaves an untraceable gap. Each log entry needs a timestamp, the actor that triggered it, and enough context to reconstruct the system's state at that moment without needing to reference anything mutable elsewhere. This is closer to event sourcing than a traditional CRUD database, and the tradeoff is that reads for "what's the current state" require replaying or maintaining a derived view, rather than just querying a table directly.

A token bucket per desk, or per API key, is the standard approach, refilling at a fixed rate and rejecting requests once the bucket is empty, which smooths out bursts without a hard cliff. The interesting design question is where the bucket's state lives if the API runs across multiple servers, a shared store like Redis keeps the limit consistent across instances, but adds a network round trip to every request, versus a local, per-instance bucket that's faster but lets a client route around the limit by hitting different servers.

Maintain two heaps, a max-heap for the lower half of the seen values and a min-heap for the upper half, keeping them balanced within one element of each other. The median is either the top of the larger heap, or the average of both tops when the heaps are equal in size. Inserting a new price costs O(log n), which is the part interviewers are actually checking for, since a naive approach that re-sorts the whole stream on every insert falls apart the moment volume picks up.

import heapq

class RunningMedian:
  def __init__(self):
    self.low = []  # max-heap, stored as negatives
    self.high = [] # min-heap

  def add(self, num):
    heapq.heappush(self.low, -num)
    heapq.heappush(self.high, -heapq.heappop(self.low))
    if len(self.high) > len(self.low):
      heapq.heappush(self.low, -heapq.heappop(self.high))

  def median(self):
    if len(self.low) > len(self.high):
      return -self.low[0]
    return (-self.low[0] + self.high[0]) / 2

Start from the core data structure, a price-time priority order book, typically two sorted structures, one for bids and one for asks, indexed by price level with a FIFO queue at each level for orders at the same price. Matching happens on every incoming order, checking whether it crosses the best price on the opposite side, and if so, filling against the oldest order at that price first. The design conversation should cover how you'd shard this by instrument to scale horizontally, since a single order book for one heavily traded symbol can't be split across machines without breaking price-time priority, but different symbols can run on entirely separate matching engines.

Decouple the two systems with a message queue or event bus, so the trading engine publishes a trade event and moves on immediately, without waiting for the risk system to acknowledge or process it. The tradeoff you have to name explicitly is that this makes the risk view eventually consistent rather than strictly real time, and the design has to account for what happens if the risk system falls behind or goes down entirely, whether trades should pause, or whether a backlog is acceptable for some bounded window. A senior answer names that tradeoff unprompted instead of waiting for the interviewer to point it out.

On the income statement, higher depreciation reduces operating income and therefore net income, which also lowers the tax bill since depreciation is tax-deductible. On the cash flow statement, net income falls, but depreciation gets added back as a non-cash expense, and since the tax savings is real cash, the net effect on cash flow from operations is actually positive, cash goes up by the tax rate times the depreciation increase. On the balance sheet, accumulated depreciation increases, reducing net PP&E, and the cash balance increases by that same tax shield amount, while retained earnings falls by the after-tax net income reduction, keeping the balance sheet in balance.