Interview Q&A

Short answer: The Singleton pattern ensures a class has only one instance and provides a global point of access to it. It’s commonly used when exactly one object is needed to coordinate actions across the system, such as configuration settings, logging, or caching.

Real-world example (ShopNest)

ShopNest payment fees use Strategy: IFeeCalculator with UPI/Card implementations chosen at runtime.

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: The Factory pattern is a creational design pattern that provides an interface for creating objects but allows subclasses or implementations to decide which class to instantiate.

Explain a bit more

It’s used to encapsulate object creation, promoting loose coupling and flexibility when the exact types of objects aren’t known until runtime. Use case: When a class can’t anticipate the class of objects it needs to create, or when you want to delegate responsibility for object creation to subclasses.

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: The Strategy pattern is a behavioral design pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime. It allows the algorithm to vary independently from clients that use it. Problem it solves: Avoids large if-else or switch statements when selecting behavior and promotes flexibility by decoupling the algorithm from the client using it.

Real-world example (ShopNest)

ShopNest payment fees use Strategy: IFeeCalculator with UPI/Card implementations chosen at runtime.

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: Applications? The Repository pattern abstracts the data access layer from the business logic by providing collection-like interface to access domain objects. It helps keep data access logic centralized and makes the codebase easier to maintain, test, and swap out data sources (e.g., switching from EF Core to Dapper or an API). Say this in the… interview

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: High-level modules should not depend on low-level modules. Both should depend on abstractions. Interfaces allow decoupling and easier testing. interface ILogger { void Log(string message); }

Example code

class FileLogger : ILogger { public void Log(string message) => Console.WriteLine("File: " + message); } class UserService
{
private readonly ILogger _logger;
public UserService(ILogger logger) { _logger = logger; }
}

Real-world example (ShopNest)

Checkout calls IPaymentGateway.Charge(). Razorpay and Stripe adapters implement the same interface, so ShopNest can switch gateways without rewriting the order service.

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: ffect it? Derived classes should be replaceable by base class without affecting correctness. Inheritance violating this principle can cause unexpected behavior.

Real-world example (ShopNest)

ShopNest has a base PaymentMethod with virtual decimal Fee(). UpiPayment and CardPayment override the fee logic without changing the checkout caller.

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: Derived classes should be replaceable by base class without affecting correctness. Inheritance violating this principle can cause unexpected behavior.

Real-world example (ShopNest)

ShopNest has a base PaymentMethod with virtual decimal Fee(). UpiPayment and CardPayment override the fee logic without changing the checkout caller.

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: Duck typing: "If it looks like a duck and quacks like a duck, it is a duck." Behavior is based on method/property availability, not type inheritance. C# does not support full dynamic duck typing, but interfaces enable a similar concept by relying on contract-based behavior. Dynamic types in C# (dynamic) can also simulate duck typing. interface IFlyable { void Fly(); }

Example code

void MakeItFly(IFlyable obj) => obj.Fly(); // Any object implementing IFlyable works

Real-world example (ShopNest)

Checkout calls IPaymentGateway.Charge(). Razorpay and Stripe adapters implement the same interface, so ShopNest can switch gateways without rewriting the order service.

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: Allows interfaces to provide default method implementations. Reason: Enables adding new methods to interfaces without breaking existing implementations. interface IPrinter

Example code

{ void Print(string msg); void PrintInfo(string msg) => Console.WriteLine("Info: " + msg); // Default }

Real-world example (ShopNest)

Checkout calls IPaymentGateway.Charge(). Razorpay and Stripe adapters implement the same interface, so ShopNest can switch gateways without rewriting the order service.

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: Use a hash map from value → index while scanning once. For each number x, check if target − x is already seen; if yes, return both indices. This is O(n) time and O(n) space — the expected answer after you briefly mention the O(n²) nested-loop brute force.

Problem statement

Given an array of integers and a target, return indices of two numbers that add up to the target. Assume exactly one solution and you may not use the same element twice.

Interview approach

1. Clarify constraints: duplicates allowed? multiple answers? need indices or values?
2. State brute force: check every pair in O(n²).
3. Propose hash map: while iterating i, look up target − nums[i].
4. Store nums[i] → i after the lookup (avoid using the same index).
5. Walk through a small example out loud.
6. State time/space and discuss follow-ups (sorted array → two pointers).

Brute force (mention first)

Nested loops comparing every pair — correct but too slow for large n.

Optimal idea

One pass with Dictionary/HashMap. Lookup is average O(1).

Sample solution

// C#
int[] TwoSum(int[] nums, int target) {
    var map = new Dictionary<int, int>();
    for (int i = 0; i < nums.Length; i++) {
        int need = target - nums[i];
        if (map.TryGetValue(need, out int j)) return new[] { j, i };
        map[nums[i]] = i;
    }
    throw new InvalidOperationException("No solution");
}

Complexity

Time O(n), Space O(n).

Edge cases to mention

• Negative numbers
• Duplicates (e.g. [3,3], target 6)
• Empty or single-element array (no solution)

Common follow-ups

• What if the array is sorted?
• Return all unique pairs instead of indices
• Three Sum

Mistakes to avoid

• Adding to the map before checking (can reuse same index)
• Forgetting to discuss complexity

Always start with brute force, then optimize — interviewers score communication as much as code.

Short answer: Track the minimum price so far while scanning left to right. At each day, compute profit = price − minSoFar and keep the maximum profit. One pass, O(1) extra space.

Problem statement

prices[i] is the stock price on day i. You may buy once and sell once later. Return the maximum profit (0 if no profit).

Interview approach

1. Clarify: only one buy and one sell; sell after buy.
2. Reject nested O(n²) “try every buy/sell pair” as too slow.
3. Maintain minPrice and maxProfit while iterating.
4. Update maxProfit when prices[i] − minPrice is better.

Sample solution

int MaxProfit(int[] prices) {
    int minPrice = int.MaxValue, best = 0;
    foreach (int p in prices) {
        if (p < minPrice) minPrice = p;
        else best = Math.Max(best, p - minPrice);
    }
    return best;
}

Complexity

Time O(n), Space O(1).

Edge cases to mention

• Strictly decreasing prices → 0
• Single day → 0
• All equal prices → 0

Common follow-ups

• Unlimited transactions
• At most k transactions
• Cooldown / fees

Say “running minimum” out loud — it shows you understand the greedy invariant.

Short answer: Insert elements into a HashSet while scanning. If an insert fails (already present), return true. Sorting and comparing neighbors also works in O(n log n) with O(1) extra space if sorting in place is allowed.

Sample solution

bool ContainsDuplicate(int[] nums) {
    var seen = new HashSet<int>();
    foreach (int n in nums)
        if (!seen.Add(n)) return true;
    return false;
}

Complexity

HashSet: Time O(n), Space O(n). Sort: Time O(n log n), Space O(1)/O(n).

Common follow-ups

• Contains Duplicate II (distance ≤ k)
• Contains Duplicate III (value range)

Ask whether O(1) space matters — that steers you to sorting vs hashing.

Short answer: Valid Anagram: count character frequencies (or sort both strings). Group Anagrams: use a frequency signature or sorted string as dictionary key and bucket words together.

Complexity

Valid: O(n). Group: O(n * k log k) with sort key, or O(n * k) with count key (k = word length).

Common follow-ups

• Anagrams with Unicode
• Find if any two are anagrams in a stream

Prefer count[26] for lowercase English — faster and shows constraint awareness.

Short answer: Push opening brackets. On a closing bracket, pop and check it matches. At the end the stack must be empty. Covers (), {}, [] in one pass.

Sample solution

bool IsValid(string s) {
    var st = new Stack<char>();
    foreach (char c in s) {
        if (c is '(' or '[' or '{') st.Push(c);
        else {
            if (st.Count == 0) return false;
            char o = st.Pop();
            if ((c == ')' && o != '(') || (c == ']' && o != '[') || (c == '}' && o != '{'))
                return false;
        }
    }
    return st.Count == 0;
}

Complexity

Time O(n), Space O(n).

Edge cases to mention

• Empty string → true
• Only closers
• Nested mixed types

Common follow-ups

• Longest valid parentheses
• Minimum remove to make valid
• Generate parentheses

This is a common phone-screen opener — nail it quickly and cleanly.

Short answer: Iterative: three pointers prev, curr, next. Flip curr.next to prev and advance. Recursive: reverse the rest, then point head.next.next = head and head.next = null. Iterative is usually preferred in interviews for O(1) stack space.

Complexity

Time O(n). Iterative space O(1); recursive space O(n) call stack.

Edge cases to mention

• Empty list
• Single node
• Cycle (clarify — usually assume none)

Common follow-ups

• Reverse nodes in k-group
• Reverse between left and right

Draw 3 nodes on the whiteboard before coding — it prevents pointer bugs.

Short answer: Use a dummy head and append the smaller of the two current nodes until one list is exhausted, then attach the remainder. Recursive merge is elegant but uses stack space.

Complexity

Time O(n + m), Space O(1) iterative.

Common follow-ups

• Merge k sorted lists (heap / divide-and-conquer)
• Merge sorted arrays in-place

Dummy node avoids special-casing the head — a small habit that impresses interviewers.

Short answer: Climbing Stairs: ways(n) = ways(n-1) + ways(n-2) — Fibonacci DP. House Robber: dp[i] = max(dp[i-1], dp[i-2] + nums[i]) — cannot rob adjacent houses. Both reduce to O(1) space with two rolling variables.

Complexity

Time O(n), Space O(1) optimized.

Common follow-ups

• House Robber II (circular)
• Climbing stairs with 1..k steps
• Decode Ways

Always define the recurrence in words before writing code.

Short answer: Maintain inclusive or exclusive bounds consistently. Compute mid carefully (lo + (hi − lo) / 2) to avoid overflow. Decide whether you want lower-bound, upper-bound, or exact match before coding.

Complexity

Time O(log n), Space O(1).

Mistakes to avoid

• Off-by-one infinite loops
• Using (lo+hi)/2 overflow on large ints
• Mixing inclusive/exclusive bounds

State the loop invariant: “answer is always inside [lo, hi]”.

Short answer: Clarify inputs/outputs/constraints first. Propose brute force, then optimize. Speak while coding, test with an example, and state complexity. Silence is riskier than imperfect code with clear thinking.

Interview approach

1. Restate the problem in one sentence.
2. Ask about constraints, duplicates, nulls, and expected complexity.
3. Outline approaches and pick one with justification.
4. Code incrementally; verify with a dry run.
5. Discuss trade-offs and follow-ups even if time ends.

Mistakes to avoid

• Jumping into code silently
• Ignoring edge cases
• Optimizing prematurely without a correct baseline

Interviewers hire teammates — communication is part of the score.

Short answer: To become a Senior Software Engineer, you must show independent ownership, reliable execution, and better engineering judgment than your current level. Seniority is not about years alone; it is about scope and consistency. Build evidence that you can deliver complex work with minimal supervision.

Step-by-step approach

1. Master one core stack deeply and become dependable for critical modules.
2. Take ownership of end-to-end delivery, including testing, deployment, and monitoring.
3. Document technical decisions and communicate trade-offs clearly across teams.
4. Mentor juniors through code reviews and design discussions.
5. Track and present measurable impact in performance reviews.
6. Align with your manager on senior-level expectations and timeline.

Real-world example

Priya at TCS wanted to move from SDE-1 to senior responsibilities but mostly handled small tickets. Rahul from Razorpay advised her to own one reliability initiative end to end and document business impact. She reduced failure rates in a core workflow and mentored two junior engineers through release cycles. In her next review cycle, she was rated for senior-track readiness.

Mistakes to avoid

• Expecting promotion only based on tenure.
• Avoiding ambiguous cross-team problems.
• Not documenting impact throughout the year.
• Ignoring mentorship and communication growth.

Toolliyo resources

• Engineering Roadmaps

Senior title follows consistent ownership evidence.

Short answer: Solution Architects bridge business needs and technical implementation. You need enough technical depth to design feasible systems and enough communication skill to align non-technical stakeholders. Business understanding is as important as architecture knowledge.

Step-by-step approach

1. Learn requirement discovery through stakeholder interviews and problem framing.
2. Build competence in cloud architecture patterns and integration design.
3. Practice converting business constraints into technical solution options.
4. Create concise diagrams and documentation for executive and engineering audiences.
5. Join pre-sales or discovery calls to improve solution communication.
6. Track delivery feedback to refine future solution quality.

Real-world example

Karan at Razorpay wanted to move from backend engineer to solution-oriented role. Isha from PhonePe advised him to join discovery calls and write architecture summaries for client-facing discussions. He learned to translate payment workflow constraints into clear integration options. This visibility helped him move toward a Solution Architect track internally.

Mistakes to avoid

• Focusing only on technical depth and ignoring business context.
• Using overly complex diagrams for non-technical audiences.
• Not validating feasibility with delivery teams.
• Neglecting cost and timeline trade-offs.

Solution architects win through business-technical translation.

Short answer: Faster promotions come from visible impact on high-priority problems, not extra hours alone. If your work consistently reduces risk, saves cost, or accelerates delivery, promotion discussions become easier. Visibility and evidence are critical.

Step-by-step approach

1. Ask your manager for explicit next-level expectations and success criteria.
2. Choose one or two high-impact projects aligned with business priorities.
3. Document measurable outcomes continuously, not only during appraisal month.
4. Improve stakeholder communication and proactive status reporting.
5. Request feedback quarterly and close gaps with concrete action plans.
6. Present promotion case with evidence mapped to role competencies.

Real-world example

Ananya at PhonePe wanted a promotion but had no structured evidence during reviews. Vikram helped her create a quarterly impact tracker covering uptime, delivery, and cross-team collaboration outcomes. She chose one critical reliability project and communicated progress consistently. Her promotion discussion became stronger and data-backed.

Mistakes to avoid

• Working hard without aligning to promotion criteria.
• Assuming manager automatically tracks all contributions.
• Avoiding feedback due to fear of criticism.
• Raising promotion request without impact documentation.

Promotions accelerate when impact is visible and role-aligned.

Short answer: A career growth plan turns vague ambition into measurable actions. It should define your target role, current gap, timeline, and progress checkpoints. Without a plan, growth becomes reactive and slower.

Step-by-step approach

1. Choose a 12 to 24 month target role and write why it matters to you.
2. Assess current skills against role expectations and identify top 5 gaps.
3. Break gaps into monthly learning and project milestones.
4. Align with manager or mentor for feedback and accountability checkpoints.
5. Track progress using evidence: projects shipped, skills acquired, and influence gained.
6. Review plan quarterly and adjust based on opportunities or market changes.

Real-world example

Meera at Infosys wanted to move from support engineering to product backend but had no clear roadmap. Rohit from Freshworks helped her define a 12-month plan with stack goals, project milestones, and interview checkpoints. She reviewed progress every quarter with her mentor and updated strategy based on feedback. The structure kept her focused and accelerated her transition.

Mistakes to avoid

• Setting goals without measurable milestones.
• Trying to improve too many skills simultaneously.
• Not revisiting the plan after market or role changes.
• Skipping mentor feedback loops.

Toolliyo resources

• Career Roadmaps

If it is not scheduled, it rarely happens.

Short answer: Floyd’s tortoise and hare: slow moves 1, fast moves 2. If they meet, there is a cycle. To find the cycle entrance, reset one pointer to head and move both one step until they meet.

Complexity

Time O(n), Space O(1) — better than HashSet of visited nodes.

Common follow-ups

• Find cycle start
• Find cycle length

Mention both HashSet and Floyd; then choose Floyd for O(1) space.

Short answer: BFS uses a queue and finds shortest paths in unweighted graphs / level order. DFS uses a stack/recursion and is natural for path existence, cycle detection, topological sort, and flood fill. Pick based on what “best” means.

If the question says “shortest” on an unweighted graph, default to BFS.