Goldman Sachs Associate Interview: What the Superday Looks Like and How to Prepare

By Preeti Verma

This article summarises what candidates have publicly reported about interviewing for Associate engineering roles at Goldman Sachs, mainly for Java backend profiles. Teams differ and processes change, so use it to shape your preparation rather than to predict exact questions.

The stages

Most accounts describe this order:

  1. An online test with two medium-level coding problems.
  2. A CoderPad screening round with a live coding problem and questions about your experience.
  3. A Superday, which is three to four back-to-back rounds covering data structures and algorithms, low-level design, high-level design and a hiring manager conversation.

The whole process can take a month or two. Among the companies we track, Goldman is reported as one of the most DSA-heavy, and candidates who were rejected most often mention the high-level design round rather than the coding rounds.

Core Java goes deep

Candidates with two to five years of experience report detailed questions such as:

  • What immutable means in Java, why String is immutable, and writing your own immutable class.
  • How HashMap and HashSet work internally, the load factor and what happens on resize.
  • Where hashCode() and equals() are used, and the contract between them.
  • Comparator versus Comparable, and sorting by a field.
  • final, finally and finalize.
  • Threads: start versus run, and extending Thread versus implementing Runnable.
  • Functional interfaces, streams and what changed between Java 7 and 8.
  • The JVM architecture and how garbage collection works.
  • Type erasure and why wrapper classes exist.

Spring Boot and microservices come up as general topics, but candidates say core Java, DSA and design matter far more here than framework detail.

Design patterns and databases

Be ready to explain Singleton, Builder, Factory and Abstract Factory, and to give an example of when you would and would not use each. On databases, expect ACID, DELETE versus TRUNCATE, SQL versus NoSQL trade-offs and how to optimise heavy writes through replication, archival, scaling and indexing.

Low-level design: the round that rewards clean thinking

Reported prompts include:

  • Design an LRU cache with O(1) operations.
  • Design a parking lot where pricing differs on weekdays, weekends and business hours, using separate strategies.
  • Design a system for a restaurant's most frequently ordered items.
  • Design snake and ladders with the full game logic.
  • Design a data structure that answers whether two or more different customers visited the same store on a given day.
  • Design a data structure where update, get and set-all all run in O(1).

For each, start by clarifying requirements, name your classes and their responsibilities, and choose a pattern only when it earns its place. The parking lot question, for example, is a natural fit for the Strategy pattern.

High-level design: where most rejections happen

Prompts include a Twitter clone (LLD for users, tweets and follows plus HLD for notifications, caching and Kafka), a URL shortener at one million requests a day and what changes at one billion, a monitoring tool, an internal upload portal and a payment system with several payment methods. There is also a case study where you walk through how you would approach a production issue.

The pattern that works is: requirements first, then rough numbers, then the API and data model, then the big boxes, then a deep dive on the hardest part and the trade-offs you accepted. Our system design guide for beginners walks through it.

DSA topics candidates mention

Recurring themes include fraction to decimal with recurring parts, expression evaluation with a calculator, rotated sorted array search, sliding window sums, H-index, meeting-room style interval problems, balancing a binary search tree, lowest common ancestor, grid path problems, BFS for shortest routes, tries, linked lists and stack problems such as valid parentheses.

Your project deep dive

Expect at least one conversation where you explain your current project's architecture, why you made each choice and what you would change. Prepare this like a talk: the problem, the design, one hard trade-off, one mistake and what you learned.

How to prepare

  • Practise design questions out loud with a timer, and record yourself.
  • Do a few DSA problems per pattern rather than many problems once.
  • Rehearse the project deep dive until it takes about five minutes.

We organised the reported questions, rewritten as scenarios, along with the reported DSA problems in the Goldman Sachs sheet. The first three questions are free to preview.