QnA

Here is a complete, question-by-question guide containing every question Divina asked, along with a high-impact sample answer tailored for an 8+ year senior full-stack developer.

Candidate Walkthrough & Projects¶

1. "Can you briefly walk me through your resume, highlighting your key skills?" (00:43)¶

Sample Answer¶

"I have over 7 years of experience as a Full Stack Developer, specializing in React.js, Node.js, TypeScript, and AWS cloud environments. Throughout my career, I've designed and delivered scalable web applications, working across both SQL and NoSQL databases like PostgreSQL and MongoDB. In my recent roles, I have focused on building complex event-driven architectures, integrating serverless AWS components like S3, Lambda, and SQS, and engineering responsive front-end applications. Beyond core development, I regularly take on technical leadership tasks—such as architectural design, code reviews, mentoring junior engineers, and establishing CI/CD quality gates."

2. "In your career, which is the project that you are very proud of, and what was your role in that?" (03:13)¶

Sample Answer¶

"The project I’m most proud of is a healthcare claims management system I’ve worked on for the past two years with a UK client. I joined at the initial architecture stage and helped bring it all the way to UAT. My role was as a Senior Full Stack Engineer, where I designed the core pipeline for claim processing. When patients are admitted, complex claim documents are uploaded to AWS S3, triggering an AWS Lambda function that pushes jobs to SQS for asynchronous, decoupled background processing. On the front end, I built interactive workflows in React so agents can modify and track claims in real time. Additionally, in a prior role for an OTT streaming platform, I engineered high-throughput Node.js/MongoDB APIs integrated with third-party partners like Jio, Dish TV, and Airtel Xstream, which handled millions of dynamic requests daily."

React & Front-End Architecture¶

3. "Can you tell me about a React application that you worked on recently?" (04:37)¶

Sample Answer¶

"My current healthcare claims application is built entirely on React with Redux for state management. The front end manages complex data grids, multi-step claim creation forms, and real-time processing updates. To maintain peak UI performance under heavy data flow, we leverage advanced React hooks—using useMemo for heavy array transformations, useCallback to prevent unnecessary child component re-renders, and custom hooks for debouncing search inputs and throttling scroll events. We also implement route-based code splitting using React.lazy and Suspense to optimize initial page load speeds."

4. "How did you handle complex state management?" (05:27)¶

Sample Answer¶

"We handle state using a multi-tiered strategy based on scope: 1. Global App State (Redux): Serves as our single source of truth for cross-cutting data like user authentication, application configuration, and shared claim datasets across multiple navigation pages. 2. Localized Feature State (Context API / Local State): For feature-specific modular flows—such as a localized form wizard or dynamic modal—we use React Context or local useState so that state changes stay isolated without bloating the global Redux store. 3. Server State (Caching Layer): We manage API responses and background sync using efficient caching patterns to avoid redundant network calls across components."

5. "What are the challenges that you have faced in React, and how did you resolve them?" (06:37)¶

Sample Answer¶

"One major challenge was dealing with performance bottlenecks caused by cascading component re-renders. We had nested dashboard widgets connected directly to a high-frequency Redux store, causing unrelated chart components to re-render every time local state changed. To resolve this, we restructured our state selector strategy using fine-grained Redux selectors with useSelector equality checks, wrapped heavy presentation components in React.memo, and migrated localized UI state into lightweight, isolated Context providers. This drastically cut down total re-render cycles and kept the UI fluid."

6. "Suppose your React application becomes slow after introducing a dashboard with multiple tables and charts. How would you troubleshoot this and which features would you introduce?" (07:28)¶

Sample Answer¶

"I would approach troubleshooting systematically: 1. Profiling: Use the React Profiler and Chrome DevTools Performance tab to identify precisely which components are lagging and why they re-rendered. 2. Virtualization / Pagination: For heavy data tables, implement list virtualization using react-window or server-side pagination so only visible rows exist in the DOM. 3. Memoization & Lazy Loading: Wrap complex charts in React.memo and wrap chart calculation logic in useMemo. Dynamically import heavy charting libraries on demand using React.lazy() so they don't block the initial main bundle."

7. "Is there any complex React feature that you have implemented?" (08:43)¶

Sample Answer¶

"Yes. In our claims platform, we implemented a complex, interactive policy rule-builder interface. It allowed non-technical users to build nested dynamic conditional logic (IF/THEN statements) on the screen. Managing this highly nested state in React without trigger-happy re-renders was difficult. I architected a normalized state structure, utilized custom recursive hooks, and wrapped input fields with debounced local buffers so that typing didn't trigger an expensive recalculation of the entire condition tree."

Node.js, Express & Back-End Architecture¶

8. "What backend services have you developed in Node.js?" (09:51)¶

Sample Answer¶

"I’ve built robust RESTful API services handling standard CRUD operations, complex business logic processing, and middleware layers. My implementations feature JWT-based authentication/authorization, secure request validation, and multi-database support across PostgreSQL and MongoDB. For high-volume endpoints, I’ve implemented Redis caching layers to store frequently queried lookup data, reducing direct database read operations by up to 60% and significantly reducing latency."

9. "What was your approach towards error handling?" (10:53)¶

Sample Answer¶

"I enforce a two-level error handling strategy in Node.js: 1. Route Level (Operational Validation): Validate all incoming parameters and payloads using schemas (like Joi or Zod). If validation fails, early-return immediately with descriptive messages and proper 400-level HTTP status codes. 2. Global Application Level: Implement an explicit AppError class extending native Error to attach metadata like HTTP status codes. All async controller errors pass to a centralized Express error-handling middleware (app.use((err, req, res, next) => ...)), ensuring stack traces are hidden in production while logging structured error details to CloudWatch."

10. "How did you structure your Express.js project?" (12:01)¶

Sample Answer¶

"I follow a clean, modular layer architecture separating concerns into distinct directory boundaries: * /controllers: Handles request parsing, response formatting, and HTTP status codes. * /services: Encapsulates core business logic, decoupled from Express framework concepts. * /models or /repositories: Manages direct database interactions and ORM/ODM schemas. * /middleware: Houses reusable cross-cutting concerns like JWT auth, logging, and error handling. * /utils & /config: Holds helper functions and environment configurations."

11. "Can you explain any microservice/modular service that you have built, and how they communicate?" (12:40 - 13:35)¶

Sample Answer¶

"In my previous OTT project, we migrated from a monolithic setup to a modular monolith architecture. We broke down business capabilities into independent service modules—such as User Auth, Media Catalog, and Payments/Subscriptions. For synchronous communications, services communicated using lightweight RESTful HTTP calls over internal network endpoints. For asynchronous background processing—such as media encoding notifications or subscription billing events—we used message queues to decouple the services so that transient downstream failures wouldn't block user HTTP requests."

12. "Suppose your API becomes slow and takes 8 to 10 seconds to respond. How will you troubleshoot this?" (13:44)¶

Sample Answer¶

"I troubleshoot API latency using a top-down, systematic process: 1. Edge/CDN Layer: Check if response caching is properly configured at the CDN level for public static or semi-static routes. 2. In-Memory Cache Layer: Verify whether Redis cache hits are succeeding or if cache invalidation/eviction issues are forcing all traffic straight to the DB. 3. Database Profiling: Execute .explain('executionStats') or EXPLAIN ANALYZE on the query to identify full collection scans, missing indexes, or unoptimized joins. 4. Application Code Profiling: Inspect Node.js event loop blocks, inefficient synchronous loops, missing pagination on large datasets, or un-promisified external API calls."

Databases & Query Optimization¶

13. "Can you give me an example of query optimization where you restructured queries?" (15:41)¶

Sample Answer¶

"In MongoDB, we had an aggregation pipeline that was timing out on large datasets. The original pipeline ran an $unwind stage on a large array before performing filtering via $match. This created millions of temporary in-memory documents before discarding most of them. I restructured the pipeline by placing the $match and $project stages at the very beginning to filter down the document set first, and only applied $unwind to the remaining 5% of records. This simple structural shift slashed execution time from over 6 seconds down to under 150 milliseconds."

14. "Have you designed the database schema yourself?" (16:51)¶

Sample Answer¶

"Yes, I regularly design database schemas starting from product requirements and high-level Entity-Relationship (ER) modeling. In relational databases like PostgreSQL, I follow 3NF normalization principles to ensure data integrity, creating dedicated lookup tables and foreign key constraints for static datasets. In NoSQL databases like MongoDB, I balance embedding versus referencing based on access patterns—embedding data that is accessed together frequently and capped in size, while using references for unbound one-to-many relationships."

15. "Suppose a user complains that searching customer records takes 20 seconds. How will you resolve this?" (17:55)¶

Sample Answer¶

"A 20-second search query usually indicates a full table or collection scan (COLLSCAN). Here is how I’d fix it: 1. Index Audit: Inspect if there are compound indexes covering the search fields (e.g., firstName, lastName, or email). If absent, create compound or text indexes so queries scan targeted b-tree buckets instead of the entire table. 2. Pattern Optimization: Check if the search uses un-indexed leading wildcard regexes (e.g., /.*smith/). Shift to indexed prefixed queries or full-text search indexes. 3. Result Bounds: Ensure pagination limits (e.g., LIMIT 20 OFFSET 0) are strictly enforced at the database layer rather than pulling all rows into Node.js memory."

AWS Cloud Infrastructure¶

16. "What AWS services have you worked with, and how do you use IAM roles?" (19:02 - 19:28)¶

Sample Answer¶

"I have hands-on experience with AWS S3, DynamoDB, Lambda, SQS, CloudWatch, and IAM. I use IAM roles following the principle of least privilege. For example, instead of embedding hardcoded secret keys inside application code, I attach an IAM execution role directly to our AWS Lambda function. That role grants explicit, granular permissions—such as s3:GetObject on a specific S3 bucket and sqs:SendMessage to a dedicated queue—ensuring services interact securely without exposing credentials."

17. "Can you briefly explain how you take a project from architecture design to development and deployment in AWS?" (20:14)¶

Sample Answer¶

"1. Requirements & LLD: We start by clarifying business scope from the Statement of Work (SOW), translating wireframes into API contracts and ER schemas. 2. Architecture: We design the flow—client requests hit a CDN/CloudFront, route through API Gateway/Load Balancers to EC2 or ECS instances, or invoke serverless Lambda functions backed by RDS/DynamoDB. 3. Development & CI/CD: We write modular TypeScript code with local environment containers, run automated test suites, and trigger CI/CD pipelines upon git merge to build and deploy artifacts to dev, UAT, and production environments."

DevOps, Testing & Engineering Leadership¶

18. "Can you explain your experience working with CI/CD pipelines?" (22:05)¶

Sample Answer¶

"I work extensively with GitLab CI and GitHub Actions pipelines. When a developer pushes code or opens a Merge Request, the pipeline automatically triggers unit tests (via Jest) and static analysis checks. Once peer code reviews are approved and merged into the target branch, the deployment pipeline package automatically builds target environment containers and deploys changes to Dev or UAT environments. Production releases require tagged releases with manual approval checkpoints."

19. "Can you explain your experience in a leadership role?" (23:13)¶

Sample Answer¶

"As a senior team member, my leadership style focuses on task prioritization, clear technical guidance, and collaborative problem-solving. I work closely with engineering managers to break down complex epics into digestible developer tickets. When technical disagreements arise, I gather the team, evaluate the pros and cons of each proposed approach based on scalability and time-to-market, and guide us toward a consensus that best serves the product."

20. "How do you conduct code reviews and ensure code quality before a Pull Request is merged?" (24:16 - 25:27)¶

Sample Answer¶

"Code quality is enforced using both automated and manual safeguards: 1. Automated Quality Gates: We run Jest for automated testing (targeting over 80% line and branch coverage) and SonarQube static analysis to catch code smells, cognitive complexity issues, and duplicate code before review. 2. Manual Peer Review: During PR review, I verify business logic correctness, ensure strict TypeScript types are maintained (no overuse of any), verify edge-case handling, and confirm that database interactions are optimized."

21. "Have you contributed to QA automation, and are you open to frameworks like Playwright?" (26:12)¶

Sample Answer¶

"My primary focus is developer unit and integration testing, along with thorough manual sanity testing of feature branches locally prior to PR creation. While I haven't written dedicated E2E automated test suites as my core responsibility, I have strong experience in TypeScript and am very open to picking up frameworks like Playwright to contribute toward end-to-end test automation."