Question 1
Difficulty: medium
Can you walk me through how you would design and build a full stack feature from the first requirement to production release?
Sample answer
I usually start by clarifying the business goal, the user flow, and the acceptance criteria before writing any code. From there, I break the feature into front-end, back-end, data, and testing tasks so I can spot dependencies early. I like to sketch the API contract first, because it keeps the frontend and backend aligned and avoids rework. On the frontend, I focus on reusable components, loading states, validation, and error handling. On the backend, I think about business logic, security, performance, and whether the database schema needs to change. I also plan for observability from the start with logs, metrics, and alerts. Before release, I verify edge cases, run tests, and get feedback in staging if possible. After deployment, I watch for issues and be ready to iterate quickly if real usage reveals something we missed.
Question 2
Difficulty: medium
How do you decide when to put logic in the frontend versus the backend?
Sample answer
I decide based on security, maintainability, and how much the logic depends on shared business rules. Anything that affects permissions, pricing, validation that must be trusted, or data integrity belongs on the backend. I do not rely on the frontend for anything the server must enforce, because clients can be bypassed or manipulated. On the other hand, UI-specific logic such as filtering, form responsiveness, temporary state, and display transformations often belongs in the frontend because it improves user experience and keeps the app responsive. I also try to avoid duplicating complex rules in both places unless there is a clear benefit, because that creates drift over time. In practice, I prefer the backend to expose clean, predictable APIs and the frontend to handle presentation and interaction. That balance usually keeps the system easier to test and easier for the team to maintain.
Question 3
Difficulty: hard
Tell me about a time you debugged a tricky production issue in a full stack application.
Sample answer
In one project, users were reporting that a page would randomly fail after submitting a form, but only in production. I started by checking logs and tracing the request through the frontend, API, and database. The frontend error message was vague, so I added better logging around the API response and reproduced the issue using the production-like data set in staging. That showed the backend was returning a validation error for records with an unexpected null field, but the frontend was not handling non-200 responses gracefully. The real issue was twofold: a missing backend guard for an edge case and weak error handling on the client. I fixed the server-side validation, updated the UI to show a useful message, and added tests for the edge case so it would not happen again. The main lesson was that production bugs often come from assumptions in more than one layer, so I always trace the full request path.
Question 4
Difficulty: hard
What is your approach to building secure full stack applications?
Sample answer
I treat security as part of the design, not as a final checklist item. On the frontend, I avoid exposing sensitive data, I sanitize user input where appropriate, and I make sure the app does not leak tokens or secrets into logs or browser storage unless there is a very deliberate reason. On the backend, I focus heavily on authentication, authorization, input validation, rate limiting, and safe database access. I prefer parameterized queries or an ORM with good safeguards to reduce injection risk. I also think about cross-site scripting, CSRF, and proper session management depending on the architecture. Beyond code, I like to use environment variables for secrets, keep dependencies updated, and review access control regularly. If the app handles sensitive information, I also pay attention to audit logging and least-privilege access. Security is strongest when both client and server are built with the same expectations.
Question 5
Difficulty: medium
How do you handle performance issues in a web application that has both frontend and backend components?
Sample answer
I approach performance by measuring first, because guessing usually wastes time. I start by identifying where the slowdown happens: network latency, server processing, database queries, or frontend rendering. On the backend, I look for expensive queries, missing indexes, repeated calls, or overly large payloads. I also check whether caching would help for data that does not change often. On the frontend, I look at render frequency, bundle size, unnecessary re-renders, and whether images or assets are being optimized properly. If the issue is user-perceived performance, I might use pagination, lazy loading, skeleton states, or prefetching to make the app feel faster even before every optimization is complete. I think the best results come from improving the biggest bottleneck first, then validating the change with real metrics. That way performance work stays practical and tied to user experience instead of becoming an endless tuning exercise.
Question 6
Difficulty: medium
Describe how you would collaborate with designers, backend engineers, and product managers on a feature with a tight deadline.
Sample answer
When the timeline is tight, I try to keep communication very concrete. I would start by confirming the minimum viable version of the feature so everyone understands what must ship now and what can wait. With product, I would clarify the priority and the tradeoffs so scope stays realistic. With design, I would identify any tricky states early, such as empty views, mobile behavior, and error scenarios, because those often become bottlenecks late in the process. With backend engineers, I would agree on the API shape as early as possible and call out any data constraints or edge cases. I also like to surface dependencies quickly so they do not surprise the team later. During the build, I keep updates short and specific: what is done, what is blocked, and what decision is needed. Under pressure, clear communication matters as much as coding speed because it prevents avoidable rework and keeps the team aligned on the same finish line.
Question 7
Difficulty: medium
What is your process for writing and maintaining tests across the stack?
Sample answer
I try to keep testing practical and layered. At the unit level, I test business logic, utility functions, and components with clear input and output behavior. For the backend, I write tests around API endpoints, validation, authorization, and the most important service logic. I also use integration tests to verify that the main pieces work together, especially where data flows across the database and API boundary. On the frontend, I focus tests on user-visible behavior rather than implementation details, because that makes them more resilient to refactoring. I do not try to test everything equally; I prioritize areas that are business-critical, easy to break, or expensive to debug manually. I also keep an eye on test maintenance by avoiding brittle mocks and by making test names descriptive. Good tests should help the team move faster, not slow them down. When written well, they become documentation for how the system is supposed to behave.
Question 8
Difficulty: medium
How would you approach a situation where the frontend and backend teams disagree on an API design?
Sample answer
I would first make sure the disagreement is about the actual user need and not just preference. Then I would compare the options against a few practical criteria: how easy the API is to use, how well it supports the UI, how stable it is for future changes, and whether it creates unnecessary complexity on either side. If one approach reduces ambiguity and makes the contract clearer, that usually wins. I also like to discuss the real usage patterns instead of abstract ideas, because concrete examples often make the right choice obvious. If there is still tension, I would look for a compromise that keeps the core data stable while allowing flexibility through optional fields or separate endpoints. My goal in those discussions is not to win an argument; it is to make sure the product ships with an API that both teams can support confidently and maintain long term.
Question 9
Difficulty: easy
Tell me about a time you had to learn a new framework or technology quickly for a project.
Sample answer
I once had to ramp up on a new frontend framework for a project where the team wanted a more maintainable component structure than the existing codebase provided. I started by learning the core concepts that affected our immediate work instead of trying to master everything at once. I built a small prototype to understand state handling, routing, and data fetching in a low-risk setting. That helped me move faster when I joined the actual feature work because I already knew the common pitfalls. I also made a habit of reading the codebase carefully and asking targeted questions rather than assuming patterns from other frameworks would translate directly. Within a short time, I was able to contribute useful work and help clean up some of the earlier implementation choices. What worked best was being disciplined about learning the essentials first and then deepening my knowledge as the project demanded it.
Question 10
Difficulty: easy
How do you keep a codebase maintainable as it grows over time?
Sample answer
I think maintainability comes from consistency, small design decisions, and resisting unnecessary complexity. I try to keep functions focused, components reusable but not overgeneralized, and APIs predictable. Clear naming matters a lot because future developers should understand intent quickly. I also prefer to separate concerns so UI, business logic, and data access do not become tangled. On larger projects, I pay attention to folder structure, shared conventions, and documentation for important patterns or decisions. I also think code review is a major part of maintainability because it helps the team catch confusing design choices before they spread. When something feels too clever, I usually ask whether a simpler version would be easier to support six months later. Good maintainability is not about writing the smallest amount of code; it is about writing code that another engineer can confidently change without fear of breaking unrelated parts of the system.
