Defend Your Project's Architecture
- Explain any project you've built with one diagram, one request path and a short data model
- Answer "why did you use this instead of that" with the constraint that made the choice
- Work through the scaling and failure follow-ups on a worked example you can practice in code
Understanding the problem
Something like this: explain the architecture of your recent project. Walk me through how a request flows from the user to the database, what your role was, and why you chose the approach you did.
Most Accenture loops don't have a classic system design round where you design a new product on a whiteboard. Campus interviews in the past year haven't had one at all. What they do have, at every level, is your own project. An Elite Engineer candidate in Bengaluru (October 2026) was asked about their internship project and their role in it. Then came the team's contribution, and then "architecture/flow of the project." An AASE candidate in mid 2026 got questions on N-tier architecture and middleware on top of the project walkthrough. Experienced hires get the same question with more pressure behind it. A full-stack developer with four years of experience (Hyderabad, March 2026) said the interviewer kept "questioning my design choices (e.g., why I used certain approaches instead of others)," down to why they used RestTemplate instead of FeignClient. A Technical Lead in February 2026 got the same pattern. The round opened with "Explain your recent project architecture," then moves to performance issues, scalable design and past trade-offs.
So treat your project as the design prompt and prepare it like one. The structure below works for any project. A small example app then runs through it end to end, along with the follow-ups that turn a walkthrough into a real design discussion.
What a good answer covers
The five parts to prepare
A strong project walkthrough has the same parts as a strong design answer. The difference is that you already know the answers, so the work is choosing what to say and in what order. Prepare these five, for each project on your resume that you'd be happy to be asked about.
One diagram, drawn in under a minute
Five to eight boxes: the client, whatever sits in front of your server, the service or services, the database, and anything asynchronous such as a queue or a scheduled job. If you can't draw it fast, you'll ramble while explaining it.
The path of one request
Pick the most important user action and follow it box by box: what the browser sends, which layer checks it, what gets read and written, what comes back. One concrete path explains more than a tour of every component.
The data model in words
Three or four main records and how they relate, plus the one constraint that keeps the data correct. Name the database and say why it fits the data.
One scaling answer and one failure answer
Know where your design breaks first if traffic grows ten times, and what happens when one dependency goes down. These are the two follow-ups that turn a walkthrough into a design round.
"Why this and not that" for every tool you name
For each framework, database and library on the diagram, have the alternative you considered and the reason you didn't pick it. If you can't defend a tool, leave it off the diagram and off the resume.
Say this
- What the system does for its users, in one sentence
- Your own part, in first person, and what the rest of the team owned
- The request path, the data model and the one rule that keeps data correct
- What you'd change now, and why
Leave it out (unless they ask)
- Every class, every endpoint, every library version
- Features you didn't touch, described as if you built them
- Buzzwords on the diagram that you can't explain one level down
- How hard the deadline was, unless it explains a design choice
How long you get
Time decides how deep to go, and it varies a lot. A 2026 campus candidate described the whole interview as about 10 to 15 minutes, so the architecture part might be two or three minutes. Have a 90-second version ready: what the app does, the diagram, one request path and your role. Stop there and let them pick what to dig into. Experienced rounds run longer and go deeper. A Java full-stack candidate in Pune (September 2026) had a technical round of about an hour and a half on Spring Boot, core Java and microservices. A Kafka engineer's round (August 2026) included a "deep dive into current project." Here the walkthrough is the opening. The follow-ups are the round. One habit pays off everywhere. A software engineer hired in Hyderabad (January 2026) put it this way: "explain everything that you write in the system design round (like why you are writing it and why you took this approach)." Every box you draw should come with its reason.
- Campus interview: about 10 to 30 min. Typical for 2026 campus interviews. The project question shares that time with HR questions.
- Experienced technical round: up to 1.5 hours. A Java full-stack round in Pune, September 2026, covering Spring Boot, core Java and microservices.
- Design-choice drilling: common in 2026. Experienced 2026 loops ask microservices and design-pattern questions, often tied to the candidate's own project.
- Classic design rounds: rare. Named design prompts show up mostly for architect, GenAI and frontend roles, and in some Europe and US loops.
An event registration app, worked end to end
To show the structure working, take a typical resume project, an event registration app. Students or employees browse upcoming events, register for a seat, join a waitlist when it's full, and get a confirmation email. It's built the way a lot of projects on Accenture resumes are built, with a React front end, a Spring Boot API and MySQL. Swap in your own project as you read. The questions apply to any stack.
The data model has three main records. A user is someone who can sign in. An event holds its title, its time, its capacity and a running count of seats_left. A registration links one user to one event and has a status that starts as confirmed or waitlisted, and can later become cancelled. Waitlisted registrations also keep their position, so the first person to join the waitlist gets the next free seat.
The rule that keeps the data correct is one row per user per event. A unique key on the pair enforces it in the database, so a double click can never create two registrations. Interviewers like this kind of detail, because it shows you thought about what can go wrong instead of just what should happen.
| Table | Fields |
|---|---|
| users | user_id · email · name · password_hash · role |
| events | event_id · title · starts_at · capacity · seats_left |
| registrations | registration_id · user_id · event_id · status · waitlist_position · idempotency_key · created_at |
The API
Four calls cover the main flows. Have them ready, because "explain your API architecture" came up in a 2026 Senior Software Engineer round in Pune, and the walkthrough below refers to these calls by name.
The architecture end to end
This is the diagram to draw first. It's a classic three-tier app, which is also the answer to "what is N-tier architecture" if you get it: a presentation tier (the React app), a business tier (the Spring Boot API) and a data tier (MySQL). Two extra boxes, a cache and a queue, each exist to answer a follow-up you can see coming. On the colors: blue is outside our system and violet is a service we run. Amber marks a queue, green marks stored data.
1) Sign in. The React app posts email and password to /auth/login. The Spring Boot API checks the password hash and returns a signed token, a JWT, which holds the user id and an expiry time. From then on the browser sends it in a header with every call, and a filter in the API checks the signature before the request goes anywhere. The server stores no session, which is why the load balancer can send each request to a different instance. JWT versus sessions is a question a senior candidate in Gurgaon got in January 2026, so have the reason ready.
2) Browse events. The app calls GET /events. The API checks the Redis cache first. On a hit it returns in a millisecond or two. On a miss it reads MySQL, stores the result in Redis for about 30 seconds, and returns it.
That short expiry means the seat count can be slightly stale. The real check happens at registration, so showing "3 seats left" when there are really 2 is harmless. What's missing so far is any plan for heavy traffic, which the scaling deep dive covers.
3) Register. The app posts to the registrations endpoint with an idempotency key, a random id it generates once per click. Inside one MySQL transaction, the API tries to take a seat by decrementing seats_left only if it's above zero. If that works, it inserts a confirmed registration. If the event is full, it inserts a waitlisted one instead.
The unique key on user and event means a second attempt by the same person finds the existing row. What happens when two people race for the last seat is the second deep dive.
4) Confirm by email. After the transaction commits, the API publishes a message to the Email queue and returns "confirmed" to the user. The Email worker picks the message up and calls the Email provider. Sending email inside the request would tie the register button's speed to an outside service we don't control. There's still a gap between "committed" and "published" that can lose a message, and the failure deep dive closes it.
Technology choices
Each of these is a "why this and not that" waiting to happen. Practice saying the reason out loud for every box on your own diagram.
- Spring Boot for the Spring Boot API, because the team knew Java and it gives a layered structure, dependency injection, validation and a security filter chain out of the box. Expect "why not Node.js": the honest answer is usually the team's skills and the client's stack, and that's a fine answer if you say it plainly.
- MySQL for the data. Registrations, users and events are related records, and taking a seat must change two rows in one transaction. A document store such as MongoDB could hold this data, but you'd be giving up joins and a unique key on the pair, which are exactly what keep it correct. If MySQL goes down, the app can still show cached events, but nobody can register until it's back, which is the right failure for a booking system.
- Redis for the Redis cache, because the event list is read on every page load and changes a few times a day. Keeping a copy in memory takes most of the read load off MySQL. If Redis fails, the API falls back to reading MySQL directly. It gets slower, and nothing breaks.
- RabbitMQ for the Email queue. A work queue fits because each email should be sent once by one worker and then disappear. Kafka is built for a different job: a log many consumers read and replay, which is more than a confirmation email needs. If the broker restarts, messages marked durable survive on disk.
- JWT for sign-in, because the API keeps no session in memory, so any instance can check any request. The trade-off is that a token can't easily be revoked before it expires, so keep expiry short, around 15 minutes, with a refresh token. If you used server sessions instead, the reason is usually easy logout, and that's a defensible choice too.
Potential deep dives
These are the follow-ups that turn your walkthrough into a design discussion. You won't get all of them. You'll very likely get one, and a candidate who has rehearsed the answer sounds very different from one meeting the question for the first time.
"Why did you use this instead of that?"
The Hyderabad full-stack candidate got this again and again, starting with why RestTemplate instead of FeignClient. It's the most predictable follow-up there is, because the interviewer only has to read your diagram and point at a box. Take one example from the event app, "Why MySQL and not MongoDB?", and compare three ways to answer it.
Approach
"The team lead chose it." "It's the industry standard." "We always use MySQL."
Challenges
Each of these says you didn't make or understand the decision. The interviewer's next question is "OK, but would you choose it again?", and you have nothing to stand on. Even if a lead made the call, you were there long enough to learn why, and that's what they're asking about.
Approach
"Registrations reference users and events, and taking a seat updates the event's count and inserts a registration together. That's a transaction across two tables, and a relational database handles it cleanly. The unique key on user and event also stops double registrations at the database level."
Challenges
This is a real answer and it's enough for most campus rounds. What's missing is the other side. You haven't said what MongoDB would have given you or when you'd pick it, so a follow-up such as "what if the schema changed every week?" can still catch you flat.
Approach
Give the Good answer, then add the trade-off and the condition: "MongoDB would have let us store each event with its attendees as one document, which is fast to read. But then a seat count and a registration live in places a single update can't keep in step, and we'd lose the unique constraint. If the data were mostly free-form, say per-event custom forms, I'd store those fields as a JSON column in MySQL rather than switch databases."
Challenges
It takes practice to say this in 30 seconds without sounding rehearsed. Prepare it for the three or four biggest choices on your diagram, never every library. And if the honest answer is "I'd choose differently now," say so and explain why. That lands better than defending a choice you no longer believe in.
The same three-part shape works for every pairing you might get. Take RestTemplate versus FeignClient. FeignClient turns a remote call into a Java interface and saves boilerplate across many services. RestTemplate is fine for one or two calls, but it's in maintenance mode, so new Spring code tends to use WebClient or RestClient instead. Monolith versus microservices has its own dive below. Write your pairs down before the interview, one line each.
What happens when two people grab the last seat?
This is the failure question for any project that books, buys or reserves something. Say an event has one seat left and two students click register within the same few milliseconds. Each request runs on its own thread, possibly on a different API instance. If your design can let both through, you've sold one seat twice, and an interviewer who asks about concurrency is checking whether you know that.
Approach
The service reads the event, checks seats_left > 0 in Java, then saves a registration and the decremented count.
Challenges
Both requests read "1 seat left" before either writes, so both pass the check and both get confirmed. A synchronized block in Java doesn't fix it, because it only locks within one JVM and there are several API instances behind the load balancer. This is the classic check-then-act race, and it's exactly the bug interviewers look for.
Approach
Make the check and the decrement a single conditional update inside the registration transaction. MySQL locks the event's row while it runs, so the two requests take turns. Whichever arrives first changes one row and gets the seat. The second finds seats_left at zero, changes no rows and goes to the waitlist, while the unique key on user and event stops the same person from clicking twice.
Challenges
It's correct across any number of API instances, because the database is the one place both requests meet. The cost is that every registration for one popular event waits for the same row lock. That's fine at a few hundred a second, and the scaling dive shows where it stops being fine.
UPDATE events SET seats_left = seats_left - 1WHERE event_id = 42 AND seats_left > 0;-- 1 row changed: the seat is yours-- 0 rows changed: full, join the waitlistApproach
Keep the conditional update and add two things. First, the client sends an idempotency key with each click, stored on the registration row. If the network drops the response and the app retries, the server finds the key and returns the original answer instead of creating a second registration. Second, cancelling a confirmed seat promotes the first waitlisted person inside the same transaction, so a freed seat can never be grabbed by a newcomer ahead of the waitlist.
Challenges
The waitlist promotion needs the oldest waitlisted row, which means an index on event and position, and a lock on that row so two cancels don't promote the same person. Promotion also has to trigger the confirmation email, which is one more message to publish reliably.
Optimistic locking is the other answer worth knowing, and JPA supports it directly with a version column on the event and a save that fails if someone else changed the row first. It suits rows that rarely collide. A popular event's seat count collides constantly, so the conditional update is the better fit here. Say that comparison and you've shown you know both. The handling contention lesson covers the general pattern.
How would it handle ten times the users?
"How would you design a scalable solution?" appears in a 2026 Technical Lead question list, and a Technical Architect in Gurgaon (February 2026) was asked how to maintain scalability in cloud native solutions. For your own project it usually arrives as "what if usage grew ten times?" Answer with numbers, even rough ones. Suppose registration for a popular college fest opens at 10 am and 50,000 students try within five minutes. That's 50,000 registrations over 300 seconds, about 170 a second on average. Bursts at the start run several times higher, so plan for around 500 a second. Each student also refreshes the event list maybe ten times, which is 500,000 reads in five minutes, roughly 1,700 a second.
Approach
"I'd break it into microservices, put them on Kubernetes and add Kafka."
Challenges
None of that touches the actual bottleneck. Splitting the app adds network calls and new failure points, and the seat row is still one row in one database. Interviewers hear this answer a lot. It tells them you reach for tools before finding the problem.
Approach
The API is stateless, so run more instances behind the load balancer and add them when CPU climbs. Serve the event list from Redis, so 1,700 reads a second mostly never reach MySQL. Add a MySQL read replica (a copy that follows the primary) for attendee lists and reports, and keep connection pools sized so a burst of API instances doesn't exhaust the database's connections.
Challenges
This handles the reads comfortably. The writes are the problem. All 500 registrations a second for the fest go to the same event row, and each one holds its lock for a couple of milliseconds. That caps out around a few hundred a second on that one row, no matter how many API instances you add.
Approach
Keep the design and fix the one spot that breaks. For a hot event, keep its seat counter in Redis too and decrement it atomically there first. Only requests that got a seat in Redis go on to MySQL, so the database sees about as many writes as there are seats instead of one per click. Everyone else is waitlisted or told it's full straight from Redis.
Challenges
Now two stores hold a seat count and they can disagree, for example if the API crashes between the Redis decrement and the MySQL insert. MySQL stays the source of truth: a small job compares the two and returns lost seats. Use this only for events you know will be hot. Most events never need it, and saying so is part of the answer.
The shape of the Great answer matters more than the Redis trick. You did the arithmetic, found the one place that breaks, and changed only that. The scaling writes lesson goes further on hot keys and counters.
What happens when a dependency goes down?
Every project calls something it doesn't control: an email service, a payment gateway, another team's API. The interviewer wants to know what your users see when it fails. In our app it's the email provider, and the question is what happens to a registration when emails can't go out.
Approach
The registration endpoint saves the row, then calls the email provider, then returns "confirmed".
Challenges
A provider that takes ten seconds makes registering take ten seconds too. When it's down, the request fails after the seat is already taken, and the user retries and may book twice. Roll back on that failure instead and the user loses the seat because of an email. The user's main action now depends on a side task.
Approach
This is the design in the diagram. The API commits, publishes a message and returns. The worker sends the email, retries failures after about 1, 2, 4 and 8 seconds, and after five attempts moves the message to a dead-letter queue for someone to look at. An outage at the provider only delays emails. Registrations keep working.
Challenges
There's a gap. If the API crashes after the database commit but before publishing, the registration exists and its email message is gone. Publishing first is no better: if the commit then fails, the user gets an email for a seat they don't have.
Approach
Write the email request into an outbox table in the same transaction as the registration, so both are saved or neither is. A small relay reads unsent outbox rows, publishes them and marks them sent. A crash anywhere just means the relay publishes a little later. The worker keys each email on the registration id so a repeat delivery sends nothing new. Around the provider call, a circuit breaker stops calling after repeated failures and tries again after a pause.
Challenges
The relay can publish a row twice if it crashes after publishing and before marking it sent, which is why the worker must ignore repeats. It's also one more process to run and watch. For a college project the Good tier is plenty, and saying "I'd add an outbox if lost emails mattered" is a strong answer by itself.
A circuit breaker came up by name in the Hyderabad round, alongside Saga and dead letter queues. Explain it by what it does. After, say, five failures in a row, the worker stops calling the provider for 30 seconds and lets messages wait in the queue instead of hammering a service that's already struggling. Then it lets one call through to test whether the provider has recovered.
"Why a monolith?" or "Why microservices?"
You'll be asked to defend whichever one you built. Our example app is a single Spring Boot service, and that's the right call for one small team. Everything deploys together, a registration is one local transaction, and debugging means reading one log. Splitting it would turn the seat-plus-registration transaction into a call between two services, which then needs a Saga (a chain of local transactions, each with an undo action if a later one fails) to stay consistent. If your project was microservices, defend the split by what it bought you: separate teams deploying independently, or one part that needed to scale on its own. Then expect the follow-ups that come with it in Accenture skill interviews. How do the services talk, through REST or a message broker? How do clients find them, through an API gateway and service discovery? What happens when one is down? The next lesson drills those questions one by one.
If you built microservices because the project template or the client already had them, say that. "The client's platform was already split this way, so we added one service to it" is an honest, common answer at a consulting firm, and it's far easier to defend than a made-up reason.
Practice the core in code
The heart of the example app fits in one class. It confirms registrations until an event is full, puts everyone after that on a waitlist, treats a repeated click as a read, and promotes the first waitlisted person when a confirmed one cancels. Building it is a good way to check you can explain the rules, because the tests below are exactly the cases from the last-seat dive.
Event Registration With a Waitlist
Problem
Write a class
EventRegistry. create(event_id, capacity) adds an event and returns true, or returns false if it already exists. enroll(event_id, user_id) returns "confirmed" if a seat is free, otherwise "waitlisted". If the user is already confirmed or waitlisted, it returns their current status and changes nothing. It returns null for an unknown event.cancel(event_id, user_id) removes the user. If they held a seat and someone is waitlisted, the first waitlisted user is confirmed and their id is returned. Otherwise it returns null. status(event_id, user_id) returns "confirmed", "waitlisted" or "none".Input encoding. A test case is a JSON array of operations. The first entry is
["EventRegistry", []] and each later entry is [method, [args]]. The expected array holds each operation's return, with null for the constructor.- EventRegistry()
- create("fest", 2)→ true
- enroll("fest", "asha")→ "confirmed"
- enroll("fest", "ravi")→ "confirmed"
- enroll("fest", "meera")→ "waitlisted"
Two seats go to the first two people. The third joins the waitlist.
Keep one record per event: its capacity, the set of confirmed users, and the waitlist in arrival order. Check whether the user is already there before handing out anything.
Event Registration With a Waitlist
Click "Run" to execute your code
enroll at once. In Python you'd add a lock per event. In the real app the conditional update plays that role across every server. Then try an idempotency key per call, so a retried request returns the original answer even if the user cancelled in between.Follow-ups to be ready for
"What was your role, and what did the team do?" The Elite Engineer candidate got this before the architecture question. A 2026 software engineer was asked the same set: your role in the project, the challenges, how you solved them, and the technologies you used. Say "I" for your work and "the team" for the rest. An interviewer who senses you're describing someone else's code will go straight to the part you didn't build.
"What was the hardest problem, and what would you change?" A campus candidate from late 2025 said most of the discussion was about why they built their projects, the challenges they faced and the technical decisions they made. Pick one real bug or limit, explain how you found it, and say what you'd do differently. "I'd add the outbox table, because we lost confirmation emails twice during a deploy" beats a vague "better testing."
"Explain the middleware flow" or "what is N-tier architecture?" A 2026 AASE interview asked about both, and a .NET loop that year asked "what is a middleware and explain its flow?" Answer from your own project. In Spring Boot, the filter chain runs before the controller, checking the token, logging and handling CORS, and an exception handler shapes errors on the way out. In ASP.NET Core it's the middleware pipeline, each piece calling the next.
If your project is a GenAI app. Expect the architecture walkthrough plus the AI-specific "why not X." A 2026 AASE project deep dive went into RAG versus fine-tuning and hallucinations. RAG fetches relevant documents at question time and passes them to the model, which keeps answers current and lets you cite sources. Fine-tuning changes the model itself, so it suits a fixed style or task better than facts that keep changing. The RAG chatbot lesson covers the full design.
What is expected at each level
Campus hires (ASE, AASE, Elite Engineer)
Mostly breadth. You have a few minutes, so you need a clean 90-second walkthrough and your role in it. Expect one or two follow-ups on the technologies you named, and maybe a concept question such as N-tier architecture. Capacity math is rarely needed here. Knowing why each piece is there matters more. The bar: you can draw your project, follow one request through it, and explain every box you drew without hesitating.
Experienced hires (Associate to Specialist)
Less walkthrough, more defense. The skill interview picks at the stack on your resume, so expect "why this instead of that" several times, plus concurrency, transactions and the microservices patterns your project used. The bar: you answer each "why not X" with a constraint and an alternative, and you can walk through one race condition and one dependency failure in your own system.
Technical Lead and architect roles
Mostly depth. Expect scalability, performance problems you've fixed and trade-offs across projects, and on architect tracks a separate design scenario as well. You should be able to say what the system cost to run, where it would break first, and what you'd change at ten times the load, with numbers. The bar: you lead the discussion from the bottleneck to the fix, name the trade-off you accepted, and say when you'd revisit it.
Common questions
Does Accenture have a system design round?
Not for most roles. Campus interviews don't include one, and experienced-hire skill interviews ask design as knowledge: your project architecture, microservices and design patterns. Named design prompts show up for architect roles, some Europe and US roles, and GenAI roles.
How do I explain my project in an Accenture technical interview?
Start with what it does in one sentence, draw the architecture, follow one request from the user to the database, then say what you personally built. Keep it under two minutes and let the interviewer choose where to go deeper.
What if my project is small, like a college project?
That's fine, and campus interviewers expect it. Small projects still have a data model, a request path and choices you can defend. Knowing why you used MySQL in a small app counts for more than a big project you can't explain.
Which project should I pick?
The one you know best, and ideally your most recent work. Experienced interviews often focus on your current project anyway. If your best work is under a client NDA, describe the architecture and the problems without naming the client or its data.
Key Takeaways
- ✓Prepare one diagram, one request path and a short data model for every project you list.
- ✓Answer every "why not X" with the constraint you had, the option you passed on and when you would switch.
- ✓Rehearse one scaling answer with numbers and one failure answer for an outside dependency.
- ✓Say "I" for your own work. Draw only boxes you can defend one level down.
Accenture interview guideKnow what Accenture asks before you walk in.
23 coding · 5 system design · 34 behavioral questions
Get their questions first.
InterviewLegend is independent and not affiliated with or endorsed by any company it covers.