Interview Q&A

Short answer: Infinite loops in useEffect occur when the effect continually triggers itself because the dependency array includes values that change as a result of the effect itself.

Explain a bit more

Common cause: If a value inside useEffect is being updated, and it's in the dependency array, React will keep rerunning the effect. How to avoid: Use an empty dependency array ([]) if the effect should run only once. Be selective with dependencies to avoid unnecessary re-renders.

Example code

useEffect(() => { // Perform API call or other side effects fetchData(); }, []); // No dependencies, effect runs only once If the dependency list has state values or props that change inside the effect, React will rerun it every time those values change. Be mindful of that!

Real-world example (ShopNest)

ShopNest’s cart icon uses useState for count and useEffect to load the cart once on mount.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Custom hooks are a powerful way to share logic between components in a reusable and encapsulated way.

Explain a bit more

A custom hook is simply a JavaScript function that uses React hooks (like useState, useEffect, etc.). Example of a custom hook: // useLocalStorage.js import { useState } from 'react'; function useLocalStorage(key, initialValue) { const [storedValue, setStoredValue] = useState(() => { const item = localStorage.getItem(key);

Example code

return item ? JSON.parse(item) : initialValue; }); const setValue = (value) => { setStoredValue(value); localStorage.setItem(key, JSON.stringify(value)); }; return [storedValue, setValue];
} export default useLocalStorage; You can then use this custom hook in any component: import useLocalStorage from './useLocalStorage'; function App() { const [name, setName] = useLocalStorage('name', 'John');
return ( <div> <input value={name} onChange={(e) => setName(e.target.value)} placeholder="Enter your name" /> </div> ); } Custom hooks allow for reusable logic (like managing form state, fetching data, etc.) and encapsulation of behavior in a way that doesn't require repeated code.

Real-world example (ShopNest)

ShopNest’s cart icon uses useState for count and useEffect to load the cart once on mount.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: In class components, the lifecycle is managed using methods like componentDidMount, componentDidUpdate, and componentWillUnmount.

Explain a bit more

With hooks, these are replaced with useEffect, which can mimic any lifecycle behavior. Lifecycle Mapping: componentDidMount: Use useEffect with an empty dependency array ([]). componentDidUpdate: Use useEffect with dependencies. componentWillUnmount: Return a cleanup function inside useEffect.

Example code

useEffect(() => { // Equivalent to componentDidMount and componentDidUpdate console.log("Component mounted or updated"); return () => { // Equivalent to componentWillUnmount console.log("Cleanup before component unmount"); }; }, [dependencies]); // Will run on mount and update based on dependencies

Real-world example (ShopNest)

ShopNest’s cart icon uses useState for count and useEffect to load the cart once on mount.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: React keys help React identify which items in a list are changed, added, or removed. Keys provide a stable identity for each element, allowing React to optimize re-renders. Important: Keys should be unique for each sibling component. Why important: Without keys, React has to re-render all list items when the list changes, which can be inefficient.

Example code

const items = ['apple', 'banana', 'cherry']; return ( <ul> {items.map((item, index) => ( <li key={index}>{item}</li> ))} </ul> ); Tip: It’s better to use a unique identifier (e.g., id) as a key instead of using index if the list can change order or content dynamically.

Real-world example (ShopNest)

When rendering cart lines, use a stable key={item.id}—not the array index—so React updates the right row after delete.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Handling errors in React is done using Error Boundaries.

Explain a bit more

They are React components that catch JavaScript errors anywhere in their child component tree and log those errors or display a fallback UI. Example of Error Boundary: class ErrorBoundary extends React.Component { constructor(props) { super(props); this.state = { hasError: false }; } static getDerivedStateFromError(error) { return { hasError: true }; // Update state to trigger fallback UI } componentDidCatch(error, info) { console.error(error, info); } render() { if (this.state.hasError) {

Example code

return <h1>Something went wrong!</h1>;
}
return this.props.children;
}
} You wrap your components inside ErrorBoundary to catch and handle errors gracefully.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: To optimize React apps for SEO (Search Engine Optimization):

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Reconciliation is the process React uses to update the UI efficiently when state or props change.

Explain a bit more

React compares the old virtual DOM with the new virtual DOM and calculates the minimal set of changes required to update the real DOM. This makes React apps fast and efficient. Why important: It helps React determine the minimal updates needed, avoiding unnecessary re-renders. React uses a diffing algorithm to compare previous and current states to optimize DOM updates.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: React uses the Virtual DOM to handle updates. When state or props change, React creates a new virtual DOM, compares it to the previous version, and calculates the most efficient way to update the actual DOM. Steps:

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: new virtual DOM, compares it to the previous version, and calculates the most efficient way to update the actual DOM. Steps: new virtual DOM, compares it to the previous version, and calculates the most efficient way to update the actual DOM. Steps:

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: React: Library for building UI, focusing on components and rendering.

Explain a bit more

Declarative and flexible: Use JavaScript to write components. React has a rich ecosystem, but you often need additional libraries for routing, state management, etc. Angular: Framework: Full-fledged framework for building web apps. Uses TypeScript by default and has built-in solutions for routing, HTTP requests, form handling, and more. Two-way data binding: Automatically synchronizes model and view. Vue: Framework: Similar to React, but provides two-way binding and template syntax. Easier to integrate into existing projects. Flexibility: Offers the reactivity model and simplicity in syntax.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: ngular: Framework: Full-fledged framework for building web apps. Uses TypeScript by default and has built-in solutions for routing, HTTP requests, form handling, and more.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: JSX transpilation refers to the process of converting JSX syntax (JavaScript XML) into regular JavaScript. Since browsers don't understand JSX directly, tools like Babel transpile JSX into valid JavaScript that browsers can execute.

Example code

const element = <h1>Hello, world!</h1>; Babel transpiles the JSX into: const element = React.createElement('h1', null, 'Hello, world!');

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: You can use libraries like react-dnd or react-beautiful-dnd for drag-and-drop functionality. Example with react-beautiful-dnd: npm install react-beautiful-dnd import { DragDropContext, Droppable, Draggable } from 'react-beautiful-dnd'; function App() { const items = ['item1', 'item2', 'item3'];

Example code

return ( <DragDropContext onDragEnd={() => {}}> <Droppable droppableId="droppable"> {(provided) => ( <ul ref={provided.innerRef} {...provided.droppableProps}> {items.map((item, index) => ( <Draggable key={item} draggableId={item} index={index}> {(provided) => ( <li ref={provided.innerRef} {...provided.draggableProps} {...provided.dragHandleProps} {item} </li> )} </Draggable> ))} {provided.placeholder} </ul> )} </Droppable> </DragDropContext> ); }

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Concurrent Mode is an experimental feature in React that enables the rendering process to be interruptible. It allows React to work on multiple tasks at once, making apps feel more responsive by prioritizing higher-priority updates (like animations or user input) over lower-priority ones.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: React.lazy enables you to dynamically import components only when they are needed, enabling code splitting and lazy loading.

Explain a bit more

const LazyComponent = React.lazy(() => import('./LazyComponent')); function App() { return ( <React.Suspense fallback={<div>Loading...</div>}> <LazyComponent /> </React.Suspense> ); } Suspense is a wrapper around lazy-loaded components that shows a loading fallback while the component is being loaded.

Real-world example (ShopNest)

ShopNest’s storefront is React: components for ProductCard, CartDrawer, and CheckoutForm, with hooks for local UI state.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: An ATS-friendly resume is simple, keyword-aligned, and evidence-based. Use plain formatting so systems can parse sections correctly, then make each bullet prove measurable impact. If ATS can read it and a recruiter can scan it in 20 seconds, you are on the right track.

Step-by-step approach

1. Use a single-column layout with standard headings like Summary, Skills, Experience, and Projects.
2. Extract required keywords from JD and incorporate them naturally in skills and bullets.
3. Rewrite every bullet as Action + Context + Result with numbers where possible.
4. Remove tables, icons, and text boxes that often break ATS parsing.
5. Keep file as PDF or DOCX only if the job portal specifically supports it.
6. Run a final ATS score check and human readability review before applying.

Real-world example

Priya applied to 40 roles from TCS and got almost no callbacks. Rahul from Razorpay reviewed her resume and found heavy design formatting with missing backend keywords. She rebuilt it into a clean one-column format with impact metrics for latency and uptime improvements. Callback rate improved within two weeks.

Mistakes to avoid

• Using visually rich templates that ATS cannot parse properly.
• Stuffing keywords unnaturally and reducing readability.
• Listing responsibilities without measurable outcomes.
• Submitting same resume to all roles without adaptation.

Toolliyo resources

• Resume Builder
• ATS Rewriter

Readable by machine first, impressive to human next.

Short answer: For most tech roles, one page is ideal up to around 5 to 7 years of experience, while two pages may be justified for senior profiles with strong breadth. The goal is not page count; it is relevance density. Keep only what supports the target role.

Step-by-step approach

1. Start with one page and expand only if removing content hurts role-fit clarity.
2. Prioritize last 5 to 8 years and compress older experience into short summaries.
3. Limit each role to high-impact bullets instead of full task history.
4. Move less relevant certifications and coursework to concise sections.
5. Check that first half page already shows role match and impact.
6. Ask a peer to do a 20-second scan test for relevance.

Real-world example

Ananya had a 3-page resume for a 4-year profile at Infosys. Vikram from Freshworks asked her to trim repetitive points and keep only role-matching achievements. She reduced it to 1.2 pages with stronger metrics and cleaner sectioning. Recruiters started responding faster because the core story became obvious.

Mistakes to avoid

• Assuming longer resume automatically looks more experienced.
• Removing key achievements just to force one page.
• Keeping outdated internships for senior roles.
• Duplicating same project details across sections.

Length should follow relevance, not ego.

Short answer: Add skills that are both role-relevant and demonstrably used in your projects or experience. Recruiters quickly reject skill lists that look inflated or disconnected from work history. Curate for depth and relevance rather than volume.

Step-by-step approach

1. Collect top 20 recurring skills from 10 target job descriptions.
2. Mark skills you have production-level experience in versus learning-stage familiarity.
3. Prioritize core stack, adjacent tools, and domain-specific capabilities.
4. Ensure each critical skill appears in at least one project/experience bullet.
5. Group skills into logical clusters like Languages, Frameworks, Cloud, and Data.
6. Remove stale or irrelevant skills every quarter.

Real-world example

Neha listed 38 skills on her Flipkart resume, but many were unused in real projects. Arjun at Zoho asked her to keep only those she could defend in interviews and map each to shipped outcomes. Her skill section became shorter but more credible. Technical panels stopped probing basic contradictions and interviews improved.

Mistakes to avoid

• Adding tools just because they are trending online.
• Mixing beginner-level and expert-level skills without distinction.
• Keeping skills unsupported by project evidence.
• Ignoring domain skills like payments, security, or analytics context.

If you cannot discuss it deeply, do not list it.

Short answer: A professional summary should state role identity, core strengths, and business impact in 3 to 4 lines. It is not an objective statement or motivational quote. Think of it as your positioning headline for recruiter skimming.

Step-by-step approach

1. Start with your role + years of experience + core domain in one sentence.
2. Add 2 key strengths aligned to target job requirements.
3. Include one measurable achievement that supports credibility.
4. Mention preferred scope, for example product backend or ML platform work.
5. Keep total length under 70 words for readability.
6. Customize summary slightly for each major role type you apply to.

Real-world example

Karthik’s resume opened with a vague line: "Seeking challenging opportunities." Isha from PhonePe helped him rewrite the summary to mention backend expertise, payment-domain experience, and latency improvement outcomes. Recruiters could now understand his profile in seconds. He started receiving more relevant interview calls.

Mistakes to avoid

• Using generic objective lines with no role signal.
• Writing a 150-word paragraph that no recruiter reads.
• Adding personal adjectives without proof.
• Forgetting to align summary with target job type.

Your summary should answer: who are you, what can you deliver?

Short answer: Project descriptions must show problem, your contribution, tech choices, and measurable outcomes. Most resumes fail because they list features, not impact. Write each project bullet so an interviewer can ask deeper follow-up immediately.

Step-by-step approach

1. Begin with the project objective and user/business context in one line.
2. Mention your exact ownership, not generic team-level contribution.
3. Include key tools and architecture choices only when relevant.
4. Add quantifiable outcome like latency, reliability, revenue, or adoption change.
5. Use strong action verbs and remove filler words.
6. Prepare a deeper verbal walkthrough for interview follow-ups.

Real-world example

Meera listed projects as "worked on dashboard module" with no details. Rohit from CRED asked her to rewrite each project around problem-solution-impact format. She added metrics like 27% faster report generation and 19% drop in support escalations. Interviewers began asking architecture questions instead of basic clarifications.

Mistakes to avoid

• Describing project as a feature list without context.
• Not clarifying individual contribution in group projects.
• Skipping outcomes and business effect.
• Using too much low-signal technical jargon.

Problem-action-impact beats feature-technology list.

Short answer: ATS optimization is about semantic match and parse accuracy. You need relevant keywords, standard structure, and clear chronology so screening systems score your profile correctly. Optimization should improve clarity, not turn your resume into keyword spam.

Step-by-step approach

1. Collect must-have terms from target JD and prioritize them by frequency.
2. Place critical keywords in Summary, Skills, and Experience where they fit naturally.
3. Use consistent date and title formats to avoid parsing confusion.
4. Remove decorative formatting, unusual fonts, and multi-column complexity.
5. Validate with ATS checker and compare score changes across versions.
6. Finalize only after both ATS score and human readability are strong.

Real-world example

Priya from Zoho had strong experience but ATS score stayed low for SDE-2 roles. Rahul helped her mirror JD terminology like "distributed systems," "message queues," and "observability" in relevant sections. She also simplified date formats and removed icon-heavy blocks. ATS match improved and she got shortlisted by two product companies.

Mistakes to avoid

• Forcing exact keyword repetition unnaturally.
• Using acronym-only skill names without expanded forms.
• Ignoring section naming conventions ATS expects.
• Optimizing for ATS and forgetting recruiter readability.

Toolliyo resources

• Resume Builder
• ATS Rewriter

ATS optimization should increase clarity, not clutter.

Short answer: No-experience resumes should highlight projects, internships, coursework relevance, and problem-solving evidence. Recruiters know you are entry-level; they want proof that you can execute and learn quickly. A focused project-first resume can outperform a generic fresher template.

Step-by-step approach

1. Open with a clear summary of target role and relevant technical stack.
2. Prioritize academic or personal projects with measurable outcomes.
3. Add internships, hackathons, open-source work, or freelancing if available.
4. Keep skills limited to tools you can explain confidently in interviews.
5. Include links to GitHub, portfolio, and deployed demos.
6. Tailor project keywords to each role before applying.

Real-world example

Ananya was a fresher from Hyderabad with no full-time work history. Vikram from Infosys helped her place projects above education and add measurable outcomes for each build. She added GitHub links and one deployed app demo in her resume header. Her profile started receiving internship-to-full-time callbacks.

Mistakes to avoid

• Leaving project section vague with no outcomes.
• Adding every class assignment as if it were production work.
• Listing advanced skills without practical proof.
• Ignoring portfolio links in resume.

For freshers, projects are your experience.

Short answer: For developers, reverse-chronological format works best because it highlights recent technical depth and growth trajectory. Keep sections predictable so both ATS and engineering managers can scan quickly. Strong developer resumes prioritize impact, stack relevance, and project ownership.

Step-by-step approach

1. Use this section order: Summary, Skills, Experience, Projects, Education, Certifications.
2. Keep experience entries reverse-chronological with clear dates and roles.
3. Write concise bullets with action verbs, tools used, and measurable impact.
4. Show architecture or scale details for senior roles where relevant.
5. Add GitHub and portfolio links near header for quick validation.
6. Ensure consistent formatting across all headings and bullet styles.

Real-world example

Neha used a design-heavy functional resume while applying from CRED to product companies. Arjun at Flipkart suggested switching to a reverse-chronological engineering-friendly format with cleaner project metrics. She also moved technical skills above education for faster relevance scanning. Recruiters responded more quickly after the format change.

Mistakes to avoid

• Choosing visual templates over parse-safe technical clarity.
• Hiding recent relevant roles below less important sections.
• Combining unrelated stacks in a single undifferentiated skills block.
• Using inconsistent tense and formatting.

Engineer resume format should optimize scan speed.

Short answer: Most resume rejection happens due to preventable errors: irrelevance, weak evidence, and formatting noise. A clean, targeted resume with quantified outcomes wins more interviews than a lengthy generic document. Review your resume like a recruiter with limited time.

Step-by-step approach

1. Run a relevance audit and remove low-signal sections that do not support target role.
2. Fix grammar, tense consistency, and formatting alignment issues.
3. Replace vague responsibility bullets with measurable delivery outcomes.
4. Check for ATS blockers like icons, columns, and broken date formats.
5. Validate contact links and ensure all project URLs are active.
6. Review with one technical peer and one recruiter-minded reviewer.

Real-world example

Karan’s resume from TCS had typo errors, broken links, and repeated bullets across two jobs. Isha from Razorpay helped him run a mistake checklist and rewrite impact lines with concrete metrics. He also removed outdated coursework and fixed ATS-unfriendly formatting. His shortlist ratio improved noticeably in the next application cycle.

Mistakes to avoid

• Submitting resume without final proofreading pass.
• Using copied bullet points from internet templates.
• Keeping irrelevant legacy technologies for modern roles.
• Ignoring broken links and incorrect contact details.

Small resume mistakes create big trust loss.

Short answer: Tailoring means changing emphasis, not inventing experience. Mirror the job language, prioritize relevant achievements, and remove distracting content. A targeted resume dramatically improves ATS match and recruiter response rate.

Step-by-step approach

1. Read JD carefully and mark required skills, domain context, and responsibility keywords.
2. Reorder experience bullets so most relevant impact appears first.
3. Swap project examples to match target role expectations.
4. Adjust summary line to reflect role title and domain focus.
5. Update skills section to emphasize directly relevant tools.
6. Run a quick ATS keyword-gap check before submitting.

Real-world example

Meera used one generic resume for all roles while applying from Infosys. Rohit from Freshworks showed her how to create two versions: backend-heavy and data-heavy. She reordered bullets and projects based on each JD instead of rewriting from scratch. Her interviews became more relevant and conversion improved.

Mistakes to avoid

• Copy-pasting JD words without matching evidence.
• Changing everything and losing profile authenticity.
• Keeping irrelevant projects at top due to personal preference.
• Sending same resume to fundamentally different role types.

Toolliyo resources

• Resume Builder
• ATS Rewriter

Tailor emphasis, never fabricate experience.