InterviewLegend

Your Project, Drawn and Defended

Signature problem
Alex Chen28 min readGuide updated
In this lesson
  • Choose a project from your CV and draw its architecture by hand in about five minutes
  • Explain what happens behind login and a password reset, step by step
  • Answer the performance questions on fast REST APIs and an overloaded database, then backpressure
  • Defend the retrieval and model choices in an AI project, then code a bounded work queue

Understanding the problem

The prompt

Something like this: walk me through a project on your CV. Draw the architecture, then tell me what happens behind the scenes when a user does something.

The two newest loops with a design question both turned to the candidate's own work. A technology apprentice in Pune in 2026 had a face-to-face round covering dynamic programming, SQL and "basic system design questions". It also went deep on their RAG application, with questions on language models and how they differ. An AVP candidate in April 2026 was asked to explain the project architecture from their CV, and then how they would challenge a vendor's design.

Older rounds point the same way. In 2025 an Associate Java backend round in Pune asked how the candidate had made their REST APIs fast and what they would do if the database was overwhelmed. It also asked how to handle producers that generate events faster than consumers can process them. In a 2023 Graduate Analyst campus round the interviewer said to draw the high-level design of the candidate's project. Then came authentication and the forgot-password flow behind it, and then, without warning, the architecture of Git.

So you pick the system. That sounds like a gift, and it is one, as long as you can defend every box you draw. The rest of this lesson takes one typical candidate project, a document question-answering app built on retrieval-augmented generation (RAG), and works it the way those rounds did. We draw it, then answer each follow-up above with a weak, a decent and a strong version. Swap in your own project as you read. The questions transfer.

The Deutsche Bank angle
Expect no standalone whiteboard design round at Deutsche Bank. Design arrives inside a technical round: a small object design on older campus loops, questions about your own work in the newest ones. Treat every project on your CV as a design you may have to draw, and drop any you can't explain line by line.

Pick the project you can defend

The interviewer picks from your CV, but you decide what's on it and which project you lead with when asked. Choose the one where you wrote most of the code and made the decisions yourself. A group project is fine if you can say exactly which part was yours. Expect the "why this project" question too. A 2024 Graduate Analyst loop in Pune asked why the candidate picked a solo project over a team one. It also asked why and how they had used AI in it.

1

It has more than one moving part

A database, an API and at least one thing that runs in the background give the interviewer something to probe. A static site or a single script leaves nothing to draw.

2

You know why each piece is there

For every box, have one sentence on why you chose it over the obvious alternative. "The tutorial used it" is honest but weak. "I needed transactions across two tables" is a design answer.

3

You have real numbers

How many users, how much data, how long the slow request took before and after you fixed it. Small numbers are fine. Invented ones fall apart under the second follow-up.

4

You know what you would change

"If I rebuilt it, I'd move uploads onto a queue" shows judgment. Expect some version of this question, and "nothing" is the wrong answer.

The example project and its scope

Functional requirements

Start the way you would in the room, by saying what the system does in two sentences. Users sign up and log in, and can reset a forgotten password. They upload PDFs, and once a document is processed they can ask questions about it and get an answer that cites the page it came from.

What the project does

  • Sign up, log in and reset a forgotten password by email
  • Upload a PDF and see when it is ready
  • Ask a question and get an answer with page citations
  • Keep each user's documents private to that user

Out of scope (say so, then move on)

  • Payments, teams and sharing between users
  • Training or fine-tuning a model
  • A mobile app
  • Running in more than one region

Non-functional requirements

Give the honest scale first. If it was a college project with forty users, say so, and then say what you designed it to handle. Interviewers respect that far more than a claim of millions of users that can't survive a follow-up. For this example, assume a couple of thousand registered students and a busy exam week. Uploads can be slow, and a document that takes two minutes to become searchable is fine as long as the user can see its status. Questions are different. The first words of an answer should appear within a couple of seconds, because the user is sitting there waiting. Privacy is the hard rule: a user must never see a passage from someone else's document.

  • One PDF: about 30 chunks. A 20-page PDF is roughly 10,000 words, or about 13,000 tokens. Cut into pieces of about 500 tokens with a little overlap, that is around 30 chunks.
  • Vectors per PDF: about 180 KB. Each chunk gets an embedding of 1,536 numbers at 4 bytes each, about 6 KB. Thirty chunks come to about 180 KB.
  • 10,000 PDFs: about 1.8 GB. Small enough for one Postgres database with a vector extension. No separate vector database is needed at this size.
  • Exam-night spike: 3,000 uploads. Three hundred students upload ten PDFs each in an hour. At five seconds per PDF, one worker needs over four hours to catch up.

The data and the API

Core entities, in words

Four records hold the whole app. A user has an email and a password hash, never the password itself. A document belongs to one user and records where the PDF is stored and its status, which starts as waiting and moves to processing. It ends as ready or failed. A chunk is one passage of a document: its text, the page it came from, and its embedding. An embedding is a list of numbers that places the passage's meaning as a point in space, so passages about similar things sit close together. A reset token is a one-time ticket for changing a password, and it expires.

Where each record lives
TableFields
usersuser_id · email · password_hash · created_at
documentsdocument_id · user_id · file_key · status · page_count
chunkschunk_id · document_id · user_id · page · text · embedding
reset_tokenstoken_hash · user_id · expires_at · used_at
All four live in Postgres, with the pgvector extension for the embedding column. Chunks carry the user id too, so every search can filter by owner before it compares vectors.

Two choices here are worth saying out loud. The chunks table repeats the user id so the privacy rule is enforced inside the search query itself. And the reset table stores a hash of the token, never the token, for the same reason the users table stores a password hash: a leaked database shouldn't hand anyone a working link.

The API

Six calls cover the app. The upload returns at once with a document id and a status, because the real work happens later in the background. The question call streams its answer, so the user sees words appear instead of a spinner.

The interface
RequestFire-and-forget
BrowserAPI servicelog in
POST /sessions { email, password }
session cookie
BrowserAPI serviceask for a reset link
POST /password-resets { email }
202, same reply whether or not the email exists
An identical reply stops anyone probing which emails have accounts.
BrowserAPI serviceset a new password
POST /password-resets/confirm { token, new_password }
204
BrowserAPI serviceupload a PDF
POST /documents (multipart file)
202, document_id, status
Returns before any processing. A full queue answers 429 with Retry-After instead.
BrowserAPI servicecheck a document
GET /documents/{document_id}
status, page_count
API serviceBrowserask a question, answer streams back
POST /questions { document_ids, question }
stream of answer text, then citations

Drawing it end to end

Draw the boxes first, then walk one request at a time through them. In the diagram, blue is outside our code (the browser and third-party services), violet is a service we run, amber is a queue that holds work, and green is where data is stored. Click any box for what it does and why it's there.

Loading diagram...

1) Log in and reset a password. The browser posts an email and password to the API service. It loads the user from Postgres and compares the password against the stored hash with a slow hashing function. On a match it creates a random session id, stores it in Redis with a 30-minute idle timeout, and sets it as a cookie. A forgotten password goes through a one-time link sent by the Email service. What exactly that token is, and what can go wrong with it, is the first deep dive.

2) Upload a PDF. The API service writes the file to File storage, inserts a document row with status waiting, puts the document id on the Ingest queue, and returns 202 Accepted. That takes a few hundred milliseconds, mostly the file transfer. One of the Ingest workers picks the message up, extracts and chunks the text, gets vectors from the Embedding API, and writes the chunks. Doing this inline would hold the request open for five seconds per PDF. What happens when uploads arrive faster than workers can keep up has its own deep dive.

3) Ask a question. The API service embeds the question, then runs one query on Postgres: the five chunks nearest to the question's vector, among chunks owned by this user. Those passages, about 2,500 tokens, go to the LLM API with the question and an instruction to answer only from them. The answer streams back to the browser as it's written, with the page numbers of the passages it used. Why chunk at all, and how to keep the model honest, is a deep dive of its own.

The Deutsche Bank angle
Deutsche Bank's India campus interviews happen on campus, and some rounds have asked for code on paper. Practise drawing this diagram by hand, in about five minutes, with labelled arrows. A neat sketch you can talk over beats a perfect one you never finish.

Technology choices

  • Postgres with pgvector, because the app needs transactions and a unique email, plus a filter by owner inside every search. At under 2 GB of vectors, one database beats running a separate vector store. If the primary dies, a replica is promoted. With asynchronous copying the last second or so of writes can be lost, and the queue retries any document caught in that gap.
  • Ingest queue on RabbitMQ or SQS. A work queue fits because each document should go to exactly one worker. A message stays hidden while a worker holds it and comes back if the worker dies. After three failed attempts it moves to a dead-letter queue, a side queue for a person to inspect.
  • File storage on S3. PDFs are written once and never edited, so the key can be the document id and a retried upload simply overwrites the same bytes.
  • Redis for sessions and rate-limit counters. Everything in it can be rebuilt or safely lost, which is why an in-memory store is acceptable here.
  • API service and Ingest workers in Spring Boot, run as containers. Neither holds state between requests, so scaling either one means starting more copies.
  • Embedding API and LLM API from a hosted provider. Calling a hosted model is the fastest way to ship a student project, and the model comparison follow-up comes back to that choice.

Say the brand you used, then defend the category. If your project used MongoDB or Kafka, explain why a document store or an event log fit your problem, because the interviewer is listening for the reasoning.

The follow-ups, as deep dives

What happens behind login and forgot password?

This came straight after the diagram in the 2023 campus round, and it's where a lot of student projects turn out to be thinner than they look. Most people used a library or a tutorial for auth. That's fine, but the interviewer wants the mechanism underneath. Start with what's stored, then walk the reset link from the click to the new password.

BadStore the password, email it back

Approach

Save the password encrypted or with a fast hash such as MD5, and on "forgot password" either email the password back or send a link like /reset?user=42.

Challenges

If you can email the password, you can decrypt it, so a leaked database leaks every password at once. A fast hash isn't much better: a single graphics card can try billions of MD5 guesses a second. A link that names the user lets anyone reset anyone's password by changing the number. Interviewers ask this partly to see whether you spot all three problems.

GoodA slow password hash and a one-time reset token

Approach

Store passwords with bcrypt or Argon2, slow hashing functions with a random salt per user, tuned so one check takes about 100 milliseconds. A reset request creates 32 random bytes as a token, stores only its SHA-256 hash with a 30-minute expiry, and emails a link carrying the raw token. On submit the server hashes what it received, finds the row, checks expiry and that it's unused, saves the new password hash and marks the token used.

Challenges

It's correct, but it leaks information and leaves doors open. The reply to "reset my password" may differ for unknown emails, which lets anyone check who has an account. Nothing limits how many resets one address can trigger. And a session stolen before the reset still works after it.

The Good tier's reset flow fits in four lines, and saying it in this order lets the interviewer follow along.

token = 32 random bytes, sent only inside the emailed link
store sha256(token), user_id, expires_at = now + 30 minutes
on submit: hash the token, find the row, check expiry and unused
save the new bcrypt hash, mark the token used, end every session
GreatClose the side doors too

Approach

Give the same reply and the same response time whether or not the email exists. Rate-limit reset requests per email and per IP address with Redis counters. A new token invalidates any older one for that user. After a successful reset, delete every session for the user, and email them that the password changed, so a real owner hears about an attacker's reset.

Challenges

Ending every session logs the user out on their other devices, which is the point but surprises people, so say it's deliberate. The equal-timing rule means the slow work, writing the token and sending the email, must not happen only for real accounts. Queue the email in both cases, or do the work after replying.

A natural next question is "sessions or JWT?" A JSON Web Token (JWT) is a signed token the server can check without a lookup, which saves a Redis call per request. The cost is that you can't easily take one back before it expires, and that matters for exactly the "end every session after a reset" rule above. For one web app, a server-side session is the simpler answer to defend. If you used JWTs, say how you handled revocation: short expiry plus a refresh token you can delete.

How did you make your REST APIs fast?

The 2025 Associate round asked this as a straight question about the candidate's own work. A weak answer lists techniques. A strong one tells a short story: this endpoint was slow, here's how I measured it, here's what I changed, and here's the number afterwards. If you never measured, measure now, before the interview. Run the slow call a hundred times and note the 95th-percentile latency, the time that 95 out of 100 requests beat.

1

Measure first, per endpoint

Log the time each request takes and look at the 95th percentile. An average hides the slow requests users complain about. A tracing tool shows which part of the request ate the time.

2

Take slow work off the request

The upload in this app returns 202 and lets a worker do the five seconds of processing. Anything that doesn't change the response the user needs right now belongs on a queue.

3

Fix the queries

The classic culprit is the "N+1" pattern: one query for a list, then one more query per item. A page of 50 documents became 51 queries. One join, or one query with an IN list, makes it two.

4

Reuse connections

Opening a database connection takes several milliseconds. A connection pool, HikariCP by default in Spring Boot, keeps a few open and lends them out. Reuse HTTP connections to the model provider as well.

5

Page and cache what repeats

Return 20 documents a page instead of all of them. Cache each user's document list in Redis for a minute, and delete that entry when they upload, so a stale list never lingers.

6

Stream what is slow by nature

The model takes several seconds to write an answer. Streaming the words as they arrive makes the first ones appear in about a second, even though the full answer takes as long as before.

Pick the two you did yourself and tell them with numbers. "The documents page did 51 queries, I replaced them with a join, and the 95th percentile dropped from about 900 milliseconds to about 120" is a complete answer. Use your own figures, though. An interviewer who asks how you measured will find out quickly if you didn't.

What if the database is overwhelmed?

The same 2025 round asked this one too. Picture exam night: 300 students, all asking questions at once, while uploads pour chunks into the same database. Login is slow, searches time out, and the database's CPU sits at 100%. The interviewer wants to know what you'd do first, and what you'd avoid.

BadAdd more API servers

Approach

The app feels slow, so run more copies of the API service.

Challenges

This usually makes it worse. Each copy brings its own connection pool, so ten copies with 20 connections each ask the database for 200 connections. Postgres allows 100 by default, and every extra connection costs it memory and adds contention. The database was the bottleneck from the start, and more callers just queue harder in front of it.

GoodFind the expensive queries and fix them

Approach

Turn on pg_stat_statements, which ranks queries by total time spent, and run EXPLAIN ANALYZE on the worst few to see whether they scan whole tables. Add the missing index, for example on chunks by user id. Fix any N+1 patterns. Put PgBouncer in front of the database, a pooler that lets hundreds of app connections share a few dozen real ones. Cache the reads that repeat, like document lists, in Redis.

Challenges

This fixes most real slowdowns, and at project scale it's the honest answer. It doesn't separate workloads, though. A heavy ingestion spike still writes to the same machine that answers logins, and every cache adds a way for users to see stale data. Decide how stale is acceptable for each cached thing.

What forces more than that is growth. Multiply the users by a hundred and the vectors grow to around 180 GB. Searches, logins and bulk chunk writes then fight over one machine's memory and disk, and tuning queries no longer buys enough.

GreatSplit the workloads, then the data

Approach

Send read-only queries, the searches and document lists, to one or more read replicas, copies of the database that follow the primary a fraction of a second behind. Keep writes and logins on the primary. Let the ingest queue throttle chunk writes so a spike can't starve everything else. Set a statement timeout so one runaway query can't hold a connection for minutes. If vectors outgrow one machine, split them by user id across several databases, since every search is already scoped to one user.

Challenges

Replicas lag, so a user who just uploaded may search a replica that hasn't caught up yet. Route that user's reads to the primary for a short time after a write. Splitting by user id makes a cross-user report harder, but the app doesn't need one.

In the room, say the order out loud: measure, fix the query, pool connections, cache, then add replicas, and split the data last. The order matters more than any single tool, because each step is cheaper than the next. The scaling reads playbook covers replicas and caching in more depth.

What if producers are faster than consumers?

The 2025 Associate round put it like this: "When producers generate events faster than consumers can process, how to handle this?" In this app the producers are uploads and the consumers are ingest workers. Exam night brings 3,000 uploads in an hour. At five seconds each, one worker clears 720 an hour, so the backlog grows by over 2,000 documents an hour. The fix is called backpressure: the slow side pushes back, so extra work waits somewhere safe or the sender is told to slow down.

BadProcess inline, or keep a list in memory

Approach

Either do the chunking and embedding inside the upload request, or push document ids onto a list inside the API process and let a background thread work through it.

Challenges

Inline processing holds every request thread for five seconds, so a spike uses up the server's threads and even logins start timing out. An in-memory list has no limit, so it grows until the process runs out of memory, and a restart or deploy silently loses every document still waiting. Users see "processing" forever.

GoodA durable queue and workers that pull

Approach

Put each document id on a durable queue and return 202. Workers pull one message at a time, which is the natural form of backpressure: a busy worker simply doesn't ask for more. Watch the queue depth and start more workers when it climbs. A message that a worker fails on comes back for a retry, and after three failures it moves to the dead-letter queue.

Challenges

Workers can't scale forever. The embedding API has its own rate limit, and past it, more workers just collect more rejected calls. The queue also has no ceiling, so one user uploading 500 files can push everyone else's documents back by an hour.

In Java, the bounded version of this idea is a few lines. A queue with a fixed capacity refuses new work when it's full, and the API turns that refusal into a polite "try again later".

java
BlockingQueue<String> waiting = new ArrayBlockingQueue<>(1000);
if (!waiting.offer(documentId)) {
return ResponseEntity.status(429).header("Retry-After", "60").build();
}
GreatBound the intake, share it fairly, pace the slow service

Approach

Cap waiting documents per user, say 20, and answer the 21st upload with 429 Too Many Requests and a Retry-After header. Workers take documents round-robin across users, so one heavy uploader can't block the others. A shared token bucket in Redis paces calls to the embedding API just under the provider's limit, and batching a document's 30 chunks into one call cuts the call count thirtyfold. The user sees an honest status, such as "12th in line".

Challenges

Rejecting uploads feels harsh, so the page has to explain it and the client should retry by itself. Per-user fairness needs a queue per user, or a scheduler in front of one queue, which is more code to own. Set the limits from measured worker speed.

The Deutsche Bank angle
That backpressure question came from a Java backend round, and a Bengaluru hiring drive in September 2026 was for a Java and Spring Boot developer role. If Java is your language, answer with Java parts: a bounded BlockingQueue, a thread pool with a fixed queue, and a 429 from the controller. Concrete classes beat a general answer about message brokers.

If your project used Kafka, the same question has a different shape. Kafka keeps every event in a log, and a slow consumer just falls behind. That gap is called consumer lag, and you measure it as the number of events not yet read. The answer is more partitions and more consumers in the group, up to one consumer per partition, plus an alert on lag. The async processing playbook covers both queue shapes.

Why chunks and vectors, and which model?

The 2026 apprenticeship round went deep on exactly this kind of project, then asked about language models and how different models compare. Any AI project on your CV invites the same pair of questions. Start with why retrieval exists at all.

BadPaste the whole PDF into the prompt

Approach

Send the full text of the user's documents with every question and let the model find the answer.

Challenges

One 20-page PDF is about 13,000 tokens. A user with ten documents sends 130,000 tokens per question, which is slow and runs past many models' context limits. Depending on the model, it costs from a couple of cents to a couple of dollars every time. Models also tend to miss facts buried in the middle of a very long prompt.

GoodChunk, embed, retrieve the nearest five

Approach

At upload, cut each document into chunks of about 500 tokens that overlap a little, so a sentence split across a boundary still appears whole in one of them. Embed each chunk once. At question time, embed the question, fetch the five nearest chunks for this user with a pgvector index, and send only those, about 2,500 tokens, with an instruction to answer from them and cite pages.

Challenges

Embeddings match meaning, which is great for "what does the course say about inflation" and weak for exact strings. A question about clause 14.2, a ticket number or a bond's ISIN code may retrieve passages that are about the right topic but lack the exact string. And when nothing relevant exists, the model still writes something that sounds plausible.

Both weaknesses justify more work. Exact identifiers are common in finance documents, and a confident wrong answer is worse than no answer.

GreatHybrid search, a relevance bar, and a test set

Approach

Run a keyword search (Postgres full-text) alongside the vector search and merge the two ranked lists, so exact codes and meaning both count. Take the top 20, rerank them with a small model that scores each passage against the question, and keep five. If even the best passage scores below a threshold, reply that the documents don't cover it. Keep 50 real questions with known answers and rerun them after every change.

Challenges

Reranking adds a few hundred milliseconds, so it only fits if the answer still starts within the latency target. The threshold needs tuning on that test set, and the test set needs updating as documents change. Uploaded text can also carry instructions aimed at the model, so treat passages as data in the prompt, never as commands.

On "which model?", compare on four things you can defend: answer quality on your own test set, cost per question, latency to the first word, and where the data goes. A hosted model is the quickest to ship. An open-weights model running on your own servers keeps documents inside your network but means owning GPUs and upgrades. In a bank, someone will ask whether client documents may leave the building, so have an answer. Also be ready for "why not fine-tune?" Fine-tuning changes how a model writes. Retrieval changes what it knows right now. For documents that change every week, retrieval is cheaper and easier to keep current.

The Deutsche Bank angle
In a 2025 Software Engineer onsite, the round billed as behavioural turned into technical probing of past projects and debugging, plus how the candidate uses AI tools. AI is a topic Deutsche Bank interviewers raise themselves now. Know your project's AI parts as well as its database, and have a straight answer on how you use coding assistants.

Practice the core in code

The backpressure answer is the one part of this design you can code in twenty minutes, so it makes good practice. The class below is the upload pipeline's waiting line: bounded, free of duplicates, and able to report each document's status.

It leaves out the network, the workers and the embedding calls. What's left decides correctness. A full line refuses work instead of growing. The same document can't be queued twice while it's in flight. Documents come out in the order they went in.

1

Bounded ingest queue with backpressure

Medium
Problem
An upload service puts documents in a waiting line for background workers. The line has a fixed capacity, so when it is full the service must refuse new work instead of growing without limit.

Write a class IngestQueue constructed with capacity, the most documents that may be waiting at once. Documents being processed don't count toward it. submit(doc_id) returns "duplicate" if the document is already waiting or processing. Otherwise it returns "rejected" if the line is full, or adds the document to the back of the line and returns "accepted".

take() removes the document at the front of the line, marks it processing and returns its id. It returns null if nothing is waiting. finish(doc_id) marks a processing document done and returns true, and returns false for any document that isn't processing. A done document may be submitted again.

status(doc_id) returns "waiting", "processing", "done" or "unknown".

Input encoding. A test case is a JSON array of operations. The first entry is ["IngestQueue", [capacity]] and each later entry is [method, [args]]. The expected array holds each operation's return, with null for the constructor.
  1. IngestQueue(2)
  2. submit("a")→ "accepted"
  3. submit("b")→ "accepted"
  4. submit("c")→ "rejected"
  5. status("c")→ "unknown"

Two documents fill the line, so the third is refused and never recorded.

How this uses the pattern

Keep a FIFO queue of waiting ids and a map from id to its status. The capacity check uses the queue length only, since processing documents have already left the line.

Write it here, or go full screen with the problem, hints and solution beside the editor.

Bounded ingest queue with backpressure

Loading...
Click "Run" to execute your code
The Deutsche Bank angle
This is the bounded line from the backpressure deep dive, small enough to code in a round. Most bugs come from counting processing documents against the capacity, or from letting a duplicate in while a worker holds the first copy. Say the rule before coding: only the waiting line is bounded, and a document is in flight from submit until finish.
Take it further
Natural extensions bring the rest of the design back. Add fail(doc_id), which puts a processing document back at the front for a retry and moves it to a dead-letter list after three failures. Then add a per-user cap, so submit takes a user id and refuses a user's 21st waiting document. Finally, discuss what changes when several worker threads call take at once.

Other follow-ups to be ready for

"Explain the architecture of Git." The 2023 interviewer jumped here straight from the candidate's project, so have a two-minute version ready. Git stores everything as objects named by the hash of their content. A blob is a file's contents, a tree is a directory listing that points to blobs and other trees, and a commit points to one tree plus its parent commits. A branch is just a small file holding one commit's hash. Because objects never change, a clone can hold the full history, and push or fetch only sends the objects the other side is missing.

"201 or 204?" This came up in the 2025 Associate round. 201 Created means a new resource exists, and the response usually says where it lives. 204 No Content means the request worked and there is nothing to send back. That suits the password change above. The upload here returns 202 Accepted, because the work has only been queued.

"Something broke in production. What do you do?" The same round asked about incident triage. Walk it in order: confirm the impact and who is affected, check what changed recently and roll it back if that is the likely cause, then read the logs and traces for the failing requests. Fix the root cause after the bleeding stops, and write down what would have caught it sooner.

"How did you test it?" That 2025 round also asked about test coverage. Name the tests that guard the risky parts: unit tests for the reset token's expiry and single use, and an integration test that a search never returns another user's chunk. "We had 80% coverage" says little. "This test fails if the privacy filter is removed" says a lot.

"How would you challenge a vendor's design?" The April 2026 AVP loop asked this alongside the CV architecture question. Hold a vendor's design to the same questions this lesson asked of yours. Where does the data go, what happens when a dependency is slow, how is access controlled, and how would you know it is failing? Ask for evidence, such as load test results or an incident history. Then agree in writing on what they will fix and when, and follow up on it.

What is expected at each level

Apprentice, intern and Graduate Analyst

At campus level the project questions sit inside a 35 to 60 minute technical round next to DSA, SQL and OOP, so they get a slice of that time. Draw the boxes, walk one request, and explain the auth flow without hand-waving. You don't need to have run anything at scale. You do need to know why you chose Postgres or MongoDB, and what each part of your own code does. The bar: you can draw your project in five minutes and explain one request end to end without guessing at any box.

Associate

With three to five years behind you, the questions move from "what is it" to "how did it behave in production". The 2025 Java round is the model. It covered API performance and a struggling database, then backpressure, incidents and tests. Each answer should name a mechanism and a number from a system you worked on, plus what you'd do differently now. The bar: every performance claim comes with how you measured it, and you reach the Good tier on the database and backpressure questions without prompting.

AVP and above

The 2026 AVP questions were about owning architecture: explain the system on your CV, then explain how you'd push back on someone else's design. Expect to defend why the system is shaped the way it is, what you'd change with hindsight, and how you weigh risk against delivery. Talk through the failure modes you planned for as well as the happy path. The bar: you lead the discussion through trade-offs and risks you chose to accept, and you'd apply the same scrutiny to a vendor's design as to your own.

The Deutsche Bank angle
Deutsche Bank's Code of Conduct lists "Evaluating risks and controls" among its five critical behaviours. At AVP and above, frame design trade-offs that way: what could fail, how you'd detect it, and who signs off on the risk. Those are the bank's own words, and they suit a design review.

Common questions

Does Deutsche Bank have a system design round?

Not as a separate round, at any level. Design shows up as one question inside a technical round. For campus candidates that has meant small object-oriented designs like a parking lot or an ATM, mostly in 2019 to 2023. In the newest loops it means drawing and defending your own project.

What project questions come up in the Deutsche Bank technical interview?

Expect to draw the architecture, then explain what happens behind it. In 2026 an apprentice was questioned on an AI project and on language models, and an AVP on the architecture of a project from their CV. Fast APIs and an overwhelmed database came up in 2025, and authentication and password reset in 2023.

Is it different for experienced hires?

The questions go deeper into production behaviour. Freshers explain what they built. Experienced candidates explain how it performed, what broke, and how they measured both.

Key Takeaways

  • ✓Recent Deutsche Bank loops test design through your own project, so draw every project on your CV and know why each box exists.
  • ✓For auth, explain slow password hashing and a hashed, single-use, expiring reset token, then the side doors.
  • ✓For performance, answer with a measured before and after number, and fix the database before adding servers.
  • ✓Backpressure means a bounded queue that refuses work when full, plus workers that pull at a pace the slowest service can take.
Deutsche Bank interview guide

Know what Deutsche Bank asks before you walk in.

28 coding · 5 system design · 29 behavioral questions

Get Premium$49 a year · Instant access
Or start freeNo card.

Get their questions first.

What the Design Question Looks LikeHad your Deutsche Bank interview?How we research

InterviewLegend is independent and not affiliated with or endorsed by any company it covers.