Aspire E Business Software Engineer Interview Guide

The 60-second brief

Aspire E Business builds and improves software products for client companies. Candidates describe Software Engineers there working across the stack: backend microservices and APIs, front ends in Angular or React, and the database connectivity behind them, alongside product managers and architects who turn client requirements into engineering tasks. The languages listed for the role are Java, C#, Python and JavaScript, with Java, .NET and Angular named as stacks that vary by team; Vue, Azure, AWS, Docker and microservices experience appear as nice-to-haves. Candidates' topic lists also include Lightning Web Components (the Salesforce UI framework), covering parent-child component communication, the publish-subscribe pattern and render performance.

This guide is for candidates entering the Aspire E Business Software Engineer loop, from campus and early-career applicants (some report a bond period attached to certain roles or campus offers) to experienced engineers, for whom candidates report high-level design topics. It covers the four reported rounds, question-specific approaches to the fifteen reported questions across core programming, live coding, SQL and architecture, the mistakes that cost points on those question types, behavioral stories to rehearse, and a seven-day plan.

Candidates report four rounds over roughly 3-5 weeks: Online Assessment, Technical Interview 1, Technical Interview 2 and an HR/Managerial Round. Some reports put it at three to four rounds over two to four weeks.

Focus areas

• Data Structures & Algorithms (DSA)
• Lightning Web Components (LWC) architecture
• Component Communication (parent-child data flow)

Overview

The reported questions fall into three groups of five. Core programming: the OOP pillars, interfaces versus abstract classes, encapsulation and polymorphism, exception handling, and shallow versus deep copies. Hands-on coding and SQL: finding duplicates in an array, checking whether two strings are anagrams, printing pyramid or star patterns, reversing a string without built-in functions, and the Nth-highest-salary query. Architecture and frameworks: Promise versus Observable, microservices versus monoliths, load balancing with session management, Angular lifecycle hooks with re-render optimisation, and keeping a real-time dashboard connected and fast.

The coding problems are short, so execution decides them. Candidates report screen-shared live coding, and these prompts either ban shortcuts (no built-in reverse) or hide edge cases (tied salaries, mixed-case anagrams, empty arrays). Write the loop yourself, state time and space complexity, and walk empty and single-element input aloud before saying you are done. Candidates also mention reversing an array without built-ins and finding the first non-repeating character in a string, so drill two-pointer swaps and frequency counting until you can write them without pausing.

For the concept questions, prepare a one-line definition, a small code example in the language you list, and the edge that a follow-up tends to reach: default methods on interfaces, try-with-resources and suppressed exceptions, a deep copy that meets a cyclic reference. Candidates report fundamentals being tested even for experienced developers, with examples such as the difference between heap and stack memory, how garbage collection works in your language, and how you would speed up a slow SQL query.

The framework and architecture questions follow your resume: candidates report that every technology you list is open to questioning. If you list Angular, know change detection, OnPush and RxJS. If you list Salesforce work, know how Lightning Web Components pass data from parent to child with @api properties, back up with CustomEvent, and across the page through a pub-sub channel. If you list backend services, be ready on service communication, data consistency and latency. Remove anything from your resume you cannot explain under three rounds of follow-up questions.

The Aspire E Business interview process

Candidates describe four stages in this order. Only the Online Assessment and Technical Interview 1 have a stated focus, so preparation for Technical Interview 2 and the HR/Managerial Round below draws on the topics candidates report across the whole loop.

Online Assessment

Candidates report the loop opens with an online assessment that mixes aptitude with technical questions. Its exact format is not reported, so prepare both halves: quantitative and logical reasoning for the aptitude part, and the fundamentals this guide covers (OOP, exceptions, SQL, array and string logic) for the technical part. Work timed practice sets so arithmetic and reasoning speed does not cost you the technical section, and keep the SQL and OOP answers below fresh enough to recognise the right option or write a short query quickly.

What to demonstrate

• Aptitude: quantitative and logical reasoning, as candidates describe the stage
• Screening-level technical fundamentals: programming concepts, SQL and basic coding logic

How to prepare

• Do two timed aptitude sets covering percentages, ratios, time-and-work and number or letter sequences, and log the question types that slow you down
• Write the Nth-highest-salary query three ways (DENSE_RANK, DISTINCT with OFFSET, correlated COUNT) so any variant is quick
• Predict by hand what short snippets print when a subclass overrides a method, when an exception is thrown inside try with a finally block, and when a shallow-copied list is mutated

Technical Interview 1

Candidates report Technical Interview 1 focuses on coding and problem-solving, and describe live coding with a shared screen. The coding questions candidates report across the loop are array and string fundamentals (duplicates, anagrams, reversing a string without built-ins, pattern printing) plus a SQL query, and this is the stage whose stated focus matches that question type. Clarify input constraints before typing, name the brute force and its complexity, write the improved version without library shortcuts when the prompt rules them out, then trace two or three test cases including empty input.

What to demonstrate

• Working code written live on a shared screen
• Choice of approach and the time and space complexity behind it
• A structured, spoken problem-solving process, which candidates report counts for more than a fast but messy solution

How to prepare

• Solve the duplicates, anagram and reverse-string questions in a plain editor without autocomplete, twice each, in your primary language
• Print a pyramid, an inverted pyramid and a diamond for n = 1, 4 and 5 after writing a row-by-row table of spaces and stars
• Add the two other problems candidates mention: first non-repeating character in a string and reversing an array without built-ins
• Rehearse narrating: state each loop's invariant aloud before writing it

Technical Interview 2

Candidates describe Technical Interview 2 only as a further technical assessment, with no reported focus. Use your preparation for it to cover what a coding stage does not: the core programming concepts (OOP, interfaces, exceptions, copying), DBMS topics such as joins, indexing and query tuning, memory management, and, if you are an experienced hire, the architecture and framework questions on microservices, load balancing, Angular and real-time dashboards. Candidates report that the projects and frameworks on your resume are open to questioning, so prepare to explain why your stack works the way it does, not only how you used it.

What to demonstrate

• Depth on core programming, DBMS and memory concepts beyond textbook definitions
• Design reasoning on services, scaling and front-end performance, which candidates report for more senior roles
• Command of the internals of frameworks you list on your resume

How to prepare

• For each resume project, sketch the architecture in five boxes, write your own contribution in one sentence, and pick one problem you solved with a measured result
• Rehearse the microservices-versus-monolith and load-balancing answers with a sketch: gateway, services, data stores, shared session store
• If you list Angular, explain OnPush and trackBy with a small component; if you list Salesforce, explain @api properties, CustomEvent and a pub-sub channel in Lightning Web Components
• Take one slow query you have written, read its execution plan, and explain which index fixes it and why

HR/Managerial Round

Candidates report the final HR/Managerial Round covers cultural fit and expectations. They also describe "Tell me about yourself" as the usual opener in the process, and report that some roles or campus offers carry a bond period, which is worth settling here if your offer details do not state it. Prepare a short technical introduction, two project stories with your own decisions in them, an honest account of a gap in your knowledge and how you closed it, and your own questions on team, stack and bond terms.

What to demonstrate

• Fit with the team and collaborative tone, as candidates describe the round
• Alignment on expectations, including any bond period candidates mention
• How clearly you explain your projects and how you handle questions outside your experience

How to prepare

• Write a five-sentence 'Tell me about yourself': background, primary language and stack, two projects with your contribution, why this role
• Prepare a story about a question or task outside your experience and the exact steps you took to find the answer
• List your questions: which client stack the team uses (Java, .NET, Angular, React), how work is assigned across projects, and the bond terms if any

Where candidates lose points

Reciting the four OOP pillars as definitions with no code, or using abstraction and encapsulation as synonyms.

For every concept question, prepare a definition plus a two-class example in your primary language, and one sentence separating the contract (abstraction) from the invariant (encapsulation). Practise the follow-ups in the guidance above, such as default-method conflicts and static method hiding, because the reported questions are basic enough that the follow-up is where an answer stands out.

Answering the Nth-highest-salary question with ORDER BY ... LIMIT and no DISTINCT, so tied salaries give the wrong row and a missing Nth value returns nothing.

Ask about ties and the empty case before writing. Use DENSE_RANK or SELECT DISTINCT with OFFSET, wrap it to return NULL, and know which RANK, DENSE_RANK and ROW_NUMBER results differ on a table with duplicate salaries.

Reaching for a built-in (reverse(), sort(), Collections.frequency) on a live coding prompt that asked for logic, or finishing without stating complexity and testing empty input.

Read the constraint back before coding ('without built-in functions, so I will swap with two pointers'). After writing, state time and space, then trace an empty input, a single element and one tricky case (a repeated duplicate, mixed-case anagram) aloud.

Listing Angular, .NET, Docker or Lightning Web Components on the resume without being able to explain how they work underneath.

Candidates report every listed technology is open to questioning. For each one, prepare the internals answer: change detection and OnPush for Angular, dependency injection lifetimes for .NET, image layers and containers versus VMs for Docker, @api, CustomEvent and pub-sub for LWC. Drop items you cannot explain.

Treating the HR/Managerial Round as a formality: a rambling introduction, vague project stories, and never asking about bond terms.

Write and rehearse a five-sentence introduction, two project stories with your own decisions and a measured result, and one story about learning something outside your experience. Since candidates report a bond period for some roles or campus offers, ask about it directly if your offer details do not state it.

Questions & practice

Write a program to find duplicates in an array.

Medium · Coding & Problem Solving

Approach

1. Clarify the output first: each duplicated value once, every repeated occurrence, or counts? Can the array be modified? What is the value range?
2. Give the ladder: brute force with nested loops is O(n^2) time, O(1) space; sorting then comparing neighbours is O(n log n) time with O(1) extra space if you may sort in place; a HashSet of seen values plus a result set is O(n) time and O(n) space and keeps first-seen order if you use a LinkedHashSet.
3. If values are guaranteed in 1..n, mention the index-marking trick: for each value v, negate the element at index |v|-1, and a value whose slot is already negative is a duplicate. O(n) time, O(1) extra space, but it mutates input and breaks with zeros or negatives.
4. For exactly one duplicate among n+1 values in 1..n without modifying the array, Floyd's cycle detection on i -> nums[i] finds it in O(n) time and O(1) space.
5. Test empty input, no duplicates, all elements equal, and a value repeated three times (should it appear once in the output?).

Follow-up

• Find duplicates without extra space and without modifying the array.
• The array is too large for memory: how do you find duplicates (external sort, or hash-partition into files)?
• Return each element with its frequency, sorted by frequency.

Implement a function to check if a string is an anagram.

Medium · Coding & Problem Solving

Approach

1. Clarify: case-sensitive? Ignore spaces and punctuation? ASCII lowercase only or arbitrary Unicode?
2. Check lengths first and return false early if they differ.
3. Sorting both strings and comparing is O(n log n) time. The better answer is a count array of size 26: increment for each character of the first string, decrement for the second, then confirm every slot is zero. O(n) time, O(1) space.
4. For Unicode, switch to a HashMap<Character or code point, count>; in Java, iterate code points rather than chars so characters outside the Basic Multilingual Plane are not split.
5. Test two empty strings, different lengths, same letters with different counts ('aab' and 'abb'), and mixed case if you normalised it.

Follow-up

• Group a list of words into anagram groups (key each word by its sorted letters or its 26-count signature).
• Find all start indices in a text where an anagram of a pattern occurs (fixed-size sliding window with counts).
• How would your solution change for full Unicode input?

Write a program to print a specific pattern (e.g., pyramid or star patterns).

Medium · Coding & Problem Solving

Approach

1. Ask which pattern and the height n, then write a row table before coding: for a centred pyramid, row i (1..n) has n - i leading spaces and 2i - 1 stars.
2. Code it as an outer loop over rows with inner loops (or a repeat count) for spaces then stars; build each row in a StringBuilder or list and print once, rather than concatenating strings in a loop.
3. Derive variants from the same table: inverted pyramid runs i from n down to 1; a diamond is a pyramid of n rows plus an inverted pyramid of n - 1 rows; a number pyramid prints j instead of '*'; a hollow pyramid prints a star only at the row's first and last positions and on the bottom row.
4. State the cost honestly: O(n^2) time because the output itself has about n^2 characters, O(n) extra space for one row.
5. Test n = 0 (prints nothing), n = 1 (one star), and check for trailing spaces if output is compared exactly.

Follow-up

• Print a hollow diamond.
• Print Pascal's triangle without computing factorials (each row from the previous one, or C(i,k+1) = C(i,k) * (i-k) / (k+1)).
• Write the pyramid recursively.

How would you reverse a string without using built-in functions?

Medium · Coding & Problem Solving

Approach

1. Clarify whether you may allocate a new array and whether the input is a char array or an immutable string (Java, C#, Python and JavaScript strings are immutable).
2. Two-pointer swap: copy into a char array, set i = 0 and j = length - 1, swap while i < j, then build the result. O(n) time, O(n) space for the array (O(1) extra if a mutable char array is given).
3. Alternative: loop from the last index down and append to a StringBuilder. Avoid result = result + ch in a loop, which is O(n^2) because each concatenation copies.
4. Mention the recursive version (reverse(s.substring(1)) + s.charAt(0)) and why it is worse: O(n) stack depth risks overflow, and substring copies make it O(n^2).
5. Edge cases: empty string, single character, palindrome, and Unicode: reversing UTF-16 code units splits surrogate pairs such as emoji, so reverse code points or grapheme clusters if that matters.

Follow-up

• Reverse the order of words in a sentence in place (reverse the whole string, then each word).
• Check whether a string is a palindrome ignoring case and non-alphanumerics.
• Reverse an array in place without built-ins, then rotate it by k positions.

Write a SQL query to find the Nth highest salary from an employee table.

Medium · Coding & Problem Solving

Approach

1. Clarify ties: if two employees share the top salary, is the second-highest the next distinct value? Usually yes, which means DENSE_RANK or DISTINCT. Also ask what to return when fewer than N distinct salaries exist (normally NULL).
2. Window-function answer: SELECT DISTINCT salary FROM (SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk FROM employee) t WHERE rnk = N. RANK would skip values after ties and ROW_NUMBER would count duplicates, both wrong here.
3. Offset answer: SELECT DISTINCT salary FROM employee ORDER BY salary DESC LIMIT 1 OFFSET N-1 (MySQL/PostgreSQL), or OFFSET N-1 ROWS FETCH NEXT 1 ROWS ONLY in SQL Server. To return NULL instead of no row, wrap it as SELECT (subquery) AS nth_salary. MySQL's LIMIT does not accept an expression, so compute N-1 into a variable inside a stored function.
4. Know the classic correlated version: SELECT DISTINCT salary FROM employee e1 WHERE N - 1 = (SELECT COUNT(DISTINCT salary) FROM employee e2 WHERE e2.salary > e1.salary). It works anywhere but is O(n^2).
5. Mention performance and NULLs: an index on salary lets ORDER BY ... LIMIT read only N entries, and NULL salaries should be excluded with WHERE salary IS NOT NULL.

Follow-up

• Return the Nth highest salary per department (PARTITION BY department_id).
• Explain the difference between RANK, DENSE_RANK and ROW_NUMBER on a table with ties.
• This query is slow on a large table: what do you check in the execution plan?

Keep soft-deleted accounts from blocking re-registration

Easy · soft delete · unique constraints · engine differences

app_user holds user_id, tenant_id, email CITEXT, password_hash (NULL for SSO principals), email_verified_at, auth_version, status ('invited','active','suspended','deactivated'), created_at, updated_at, deleted_at. Two live accounts for one address inside a tenant must be impossible, but an address freed by a soft delete must be reusable, and the same tenant may delete and re-register it repeatedly. Write the uniqueness DDL for PostgreSQL 16, then the equivalent for MySQL 8 where partial indexes do not exist, and say what each permits once three deleted rows already hold that address.

Approach

1. Start from what is actually unique: not (tenant_id, email), but (tenant_id, email) among live rows. PostgreSQL says that directly — CREATE UNIQUE INDEX app_user_live_email ON app_user (tenant_id, email) WHERE deleted_at IS NULL. A full constraint over the same two columns burns the address permanently the first time someone deletes an account.
2. Keep case-insensitivity in the type or the index, never in the application: CITEXT as given, or UNIQUE (tenant_id, lower(email)) as an expression index where the extension is unavailable. A case-sensitive unique column is exactly how two accounts for one human appear.
3. For MySQL 8 the predicate has to move inside the key: add a discriminator column that is a constant 0 while the row is live and is set to user_id on delete, with UNIQUE (tenant_id, email, deleted_marker). Live rows share the constant and still collide; deleted rows differ from each other and stop colliding.
4. State the NULL variant and its dependency: leaving the marker NULL for deleted rows also works, because a unique index treats NULLs as distinct — true in MySQL, and true in PostgreSQL only under the default NULLS DISTINCT, which PostgreSQL 15 lets you reverse. Check the polarity against the three existing deleted rows: constant-on-live is what preserves the collision you want, and reversing it silently admits duplicate live accounts.

Follow-up

• A deleted account re-registers with the same address the next day. Do the old resource rows follow the new user_id, and how does the API keep the two principals apart?
• How do you honour an erasure request while resource_revision.actor_user_id still references this table?

Explain the core Object-Oriented Programming (OOPs) concepts with real-time examples.

Medium · Technical & Core Programming

Approach

1. Name the four pillars and give each a one-line definition plus a concrete object: encapsulation (a BankAccount whose balance is private and only changes through deposit/withdraw that reject negative amounts), abstraction (a PaymentGateway interface hiding which provider charges the card), inheritance (SavingsAccount extends Account and reuses its fields), polymorphism (a List<Shape> where each element's area() runs its own implementation).
2. Separate abstraction from encapsulation explicitly: abstraction decides what callers see (the contract), encapsulation protects how state is kept valid (the invariant). Mixing them up is the most common slip.
3. Show you know inheritance's cost: it is an is-a relation and should respect substitutability (the Square-extends-Rectangle problem breaks Liskov), and composition (has-a) is usually the safer reuse mechanism.
4. Tie polymorphism to its two forms: compile-time (method overloading, generics) and runtime (overriding resolved by dynamic dispatch on the object's actual type).
5. Close with one example from your own project, e.g. a NotificationSender interface with Email and SMS implementations that replaced a switch on a type string.

Follow-up

• When would you choose composition over inheritance, and what does it buy you in testing?
• Why does Java not allow a class to extend two classes, and how do interfaces avoid the diamond problem?
• What is the difference between method overloading and method overriding?

What is the difference between an interface and an abstract class?

Medium · Technical & Core Programming

Approach

1. Start from what each can hold: an abstract class can have instance fields, constructors, concrete and abstract methods, and any access modifier; an interface defines a contract, its fields are implicitly public static final in Java, and since Java 8 it can carry default and static methods (private methods since Java 9).
2. State the inheritance rule: a class extends one abstract class but implements many interfaces. In C#, the same split holds, and C# 8 added default interface methods.
3. Give the decision rule: abstract class when closely related types share state and a fixed algorithm skeleton (template method); interface when unrelated types share a capability (Comparable, Runnable, IDisposable).
4. Mention the default-method conflict: if a class implements two interfaces with the same default method, it must override it and can delegate with InterfaceName.super.method().
5. Use a small example: abstract class Employee with a name field and abstract calculatePay(); interface Payable implemented by both Employee and Invoice.

Follow-up

• Can an abstract class have a constructor if you cannot instantiate it? When does it run?
• What is a functional interface and how does it relate to lambdas?
• If interfaces can now have default methods, why do abstract classes still exist?

Explain the concept of encapsulation and polymorphism.

Medium · Technical & Core Programming

Approach

1. Encapsulation: bundle data with the methods that maintain its invariants and hide the fields. Show it with private fields, validated mutators (or none, for an immutable class), and returning defensive copies of internal collections rather than the live reference.
2. Point out that a getter and setter for every field is not real encapsulation: if any caller can set any value, the class enforces nothing.
3. Polymorphism: one interface, many implementations. Compile-time via overloading (resolved by the static types of the arguments); runtime via overriding (resolved by the object's actual class through virtual dispatch).
4. Give a before-and-after: a switch on shape type in calculateArea() versus each Shape overriding area(), so adding a Triangle touches one new class instead of every switch.
5. Know the edges: static and private methods are not overridden (static methods are hidden), and fields are not polymorphic in Java; a field access uses the reference's declared type.

Follow-up

• Can you override a static method? What happens if a subclass declares one with the same signature?
• How does the JVM or CLR decide which overridden method to call at runtime?
• How would you make a class immutable, and what does that do for thread safety?

How do you perform exception handling in your preferred language?

Medium · Technical & Core Programming

Approach

1. Answer in your primary language with its exact constructs. Java: try/catch/finally, checked versus unchecked exceptions, multi-catch, and try-with-resources for anything AutoCloseable. C#: try/catch/finally, the using statement, exception filters with when, and no checked exceptions. Python: try/except/else/finally and raise ... from. JavaScript: try/catch, rejected Promises, and await inside try.
2. Give the rules you actually follow: catch the most specific type, never swallow an exception silently, wrap low-level exceptions in a domain exception while keeping the cause, and release resources in finally or a resource statement.
3. Show the layering: let exceptions travel up to a boundary (an API layer or a global handler) that logs once with context and maps them to a response code, instead of logging at every level.
4. Cover the traps: a return in finally discards the exception; in C#, 'throw;' preserves the stack trace while 'throw ex;' resets it; in try-with-resources, an exception from close() is attached as a suppressed exception.
5. Mention custom exceptions: when a caller needs to react differently (InsufficientFundsException), not for every error.

Follow-up

• When would you use a checked exception versus an unchecked one?
• What happens if both the try block and close() in try-with-resources throw?
• How do you handle errors from asynchronous code or a Promise chain?

What are the differences between shallow copy and deep copy?

Medium · Technical & Core Programming

Approach

1. Define it by references: a shallow copy creates a new top-level object but shares nested objects with the original; a deep copy recursively copies nested objects so the two are fully independent.
2. Demonstrate the bug a shallow copy causes: copy a User with an addresses list, add an address to the copy, and the original changes too.
3. Name the language tools: Java Object.clone() is shallow by default (copy constructors are the clearer route); C# MemberwiseClone is shallow; Python copy.copy versus copy.deepcopy; JavaScript spread and Object.assign are shallow, structuredClone is deep.
4. Cover the edge cases: JSON.parse(JSON.stringify(x)) drops functions and undefined, turns Dates into strings and throws on cycles; a correct deep copy of a graph keeps a visited map (Python's deepcopy memo dict does this) to handle cycles and shared references.
5. Mention the trade-off: deep copies cost time and memory proportional to the object graph, and immutable nested objects can be shared safely, which is why immutable data makes shallow copies safe.

Follow-up

• How would you deep copy an object graph that contains a cycle?
• Why do immutable updates (a new array instead of push) matter for change detection in Angular or React?
• Is String in Java affected by shallow copying? Why not?

Explain the difference between Promise and Observable.

Medium · System Architecture & Frameworks

Approach

1. Contrast on four axes: a Promise is eager (the work starts when it is created), resolves exactly once with one value or error, cannot be cancelled natively, and its callbacks always run asynchronously as microtasks. An RxJS Observable is lazy (nothing runs until subscribe), can emit zero to many values over time, can be cancelled by unsubscribing, and composes through operators.
2. Give the Angular context: HttpClient returns an Observable that emits once and completes, so it can be cancelled, retried (retry) and combined (forkJoin, combineLatest) in ways a Promise cannot.
3. Use the typeahead example: valueChanges piped through debounceTime, distinctUntilChanged and switchMap, where switchMap unsubscribes from the stale request when a new keystroke arrives.
4. Cover cold versus hot: a cold Observable (an HTTP call) runs once per subscriber; a Subject or shareReplay shares one execution among subscribers.
5. Mention leaks and conversion: unsubscribe in ngOnDestroy, use takeUntil or the async pipe; convert with firstValueFrom or lastValueFrom, since toPromise is deprecated in RxJS 7.

Follow-up

• What is the difference between switchMap, mergeMap, concatMap and exhaustMap?
• Subject versus BehaviorSubject versus ReplaySubject: when do you use each?
• How do you find and fix a subscription leak in an Angular component?

Describe the Microservices architecture and how it differs from monolithic systems.

Medium · System Architecture & Frameworks

Approach

1. Define both: a monolith is one deployable unit with in-process calls and usually one database; microservices split the system along business capabilities into independently deployable services, each owning its own data and communicating over the network.
2. Give the gains of microservices: independent deployment and scaling, fault isolation, team autonomy, freedom of stack per service, and containerised deployment (Docker) per service.
3. Give the costs just as concretely: network latency and partial failure, no single ACID transaction across services (sagas and the transactional outbox instead), distributed tracing and correlation IDs for debugging, API versioning, service discovery and an API gateway.
4. Name communication styles: synchronous REST or gRPC for request-response, asynchronous messaging or pub-sub for events that several services react to, with idempotent consumers because messages can be redelivered.
5. Close with a decision rule: start as a modular monolith with clear module boundaries, and extract a service when one module needs a separate scaling profile, release cadence or team; migrate with the strangler-fig pattern.

Follow-up

• How do you keep an order and its payment consistent across two services (saga with compensating actions, choreography versus orchestration)?
• A downstream service is slow: how do you stop it taking your service down (timeouts, retries with backoff, circuit breaker, bulkhead)?
• How would you break an existing monolith into services without a big-bang rewrite?

Explain the Angular lifecycle hooks and how to optimize component re-rendering.

Medium · System Architecture & Frameworks

Approach

1. List the hooks in order: ngOnChanges (inputs changed; before ngOnInit, only if inputs exist), ngOnInit (one-time setup), ngDoCheck (custom checks, every cycle), ngAfterContentInit/Checked (projected content), ngAfterViewInit/Checked (own view and children; @ViewChild is ready), ngOnDestroy (unsubscribe, clear timers). The constructor is for dependency injection, not data loading.
2. Optimise re-rendering with ChangeDetectionStrategy.OnPush: the component is checked only when an input reference changes, an event fires inside it, an async pipe emits, or markForCheck is called. That requires immutable updates (a new array, not push).
3. Add trackBy on *ngFor (or track in the @for block of newer Angular versions) so a list refresh reuses DOM nodes instead of rebuilding them.
4. Remove per-cycle work from templates: replace method calls with pure pipes or precomputed fields, and run high-frequency handlers (scroll, mousemove, sockets) outside the zone with NgZone.runOutsideAngular, re-entering only when the view needs an update. Signals in recent Angular versions narrow updates further.
5. Name the error to expect: ExpressionChangedAfterItHasBeenCheckedError when a value bound in the template is changed in ngAfterViewInit; fix it by moving the change earlier or deferring it.

Follow-up

• Why does pushing an item into an array not update an OnPush child component?
• What is the cost of putting heavy logic in ngDoCheck or ngAfterViewChecked?
• How would you find which component is re-rendering too often?

How do you manage connectivity and performance in a real-time dashboard system?

Medium · System Architecture & Frameworks

Approach

1. Pick the transport by direction and frequency: WebSockets for bidirectional, high-frequency updates; Server-Sent Events for server-to-client streams over plain HTTP with built-in reconnect and Last-Event-ID; polling only when updates are rare. Say why you chose it.
2. Make connectivity robust: heartbeats (ping/pong) to detect dead connections, reconnect with exponential backoff and jitter so clients do not reconnect in a stampede, and resume via sequence numbers: send a snapshot on connect, then deltas, and ask for missed events after a gap.
3. Scale the backend with publish-subscribe: data producers publish to a broker or Redis pub/sub channel, and each socket server subscribes and fans out to its connected clients, so connection servers stay stateless; aggregate or downsample on the server rather than shipping raw events.
4. Protect the browser: coalesce bursts (keep only the latest value per widget), batch DOM updates per animation frame, virtualise long tables, use OnPush or memoised components, and move heavy computation into a Web Worker.
5. Handle backpressure and staleness explicitly: drop or merge intermediate values for slow clients, and show a last-updated time or a disconnected banner instead of silently stale numbers.

Follow-up

• A client was offline for ten minutes: how does it catch up without reloading everything?
• How would you support many thousands of concurrent dashboard connections?
• How do you test that reconnect and resume work correctly?

Listing latency scales with page size, not with filters

Easy · n+1 · latency · query batching

The tenant listing endpoint reads resource filtered by tenant_id and status, ordered by updated_at DESC, and returns each row plus the owner's display name from app_user and the actor of that resource's latest resource_revision. p99 is 55 ms at 10 rows per page and 1.4 s at 200. Database telemetry shows 401 statements per request, each under 1 ms, and nothing in the slow-query log. Diagnose the cause and give the fix, stating the statement count per request and the p99 you expect afterwards.

Approach

1. Read the counters before forming a theory. 401 statements for 200 rows is one driver query plus two per row, and sub-millisecond execution with an empty slow-query log rules out a bad plan. The time is round trips, which is why it is invisible in every per-query metric and scales with rows returned rather than with filter selectivity.
2. Name the two per-row statements from their normalised text: a single-row app_user lookup by user_id, and a resource_revision lookup by resource_id ordered by version DESC LIMIT 1. Confirm by dropping those two response fields and watching the statement count fall to one. That locates the calls in the serialisation layer, not the repository.
3. Check that the arithmetic accounts for the whole gap. Measure one round trip to the replica in isolation; 400 trips at roughly 3 ms of network plus 0.2 ms of execution is about 1.3 s on top of a 55 ms baseline, which matches. If the multiplication had fallen short, the N+1 would only be part of the story and you would keep looking.
4. Batch both lookups. Collect owner_user_ids and resource_ids from the driver query, then issue WHERE tenant_id = $1 AND user_id = ANY($2) for the users, and PostgreSQL's SELECT DISTINCT ON (resource_id) ... WHERE resource_id = ANY($2) ORDER BY resource_id, version DESC for the latest revision, which the UNIQUE (resource_id, version) index serves directly. On an engine without DISTINCT ON, use a lateral join or a row_number window. Three statements per request at any page size.

Follow-up

• The page size is capped at 200 today. What breaks first if it is raised to 2,000, and is it still this bug?
• How do you stop the next N+1 from reaching production, given that no individual query is slow and the endpoint's tests pass?

Suggested practice checklist

Each day targets one cluster of the fifteen reported questions, ordered to match the reported loop: fundamentals for the assessment, live coding for Technical Interview 1, depth and architecture for Technical Interview 2, and stories for the HR/Managerial Round.

Day 1 — OOP fundamentals with code

• Write a BankAccount, a Shape hierarchy and a NotificationSender interface in your primary language that between them demonstrate all four OOP pillars
• Answer the interface-versus-abstract-class question aloud, including default methods and the diamond conflict, and write the example that resolves it with InterfaceName.super
• Write the switch-on-type versus overriding comparison for the encapsulation and polymorphism question, plus one example of static method hiding

Deliverable: Three small compiled code files and a one-page sheet of definitions with an example for each OOP question.

Day 2 — Exceptions, copying and memory

• Write code that shows try-with-resources (or using in C#), a custom exception that keeps its cause, and the return-in-finally trap, then explain each aloud
• Reproduce the shallow-copy bug with a nested list, fix it with a copy constructor or deepcopy, then write a deep copy that handles a cycle with a visited map
• Write a short answer on heap versus stack and how garbage collection works in your language

Deliverable: An exceptions demo file, a copy demo with the cycle-safe deep copy, and a written heap-versus-stack answer.

Day 3 — Array and string live coding

• Solve finding duplicates three ways (sorting, HashSet, index marking) and write the complexity of each beside the code
• Solve the anagram check with a 26-slot count array, then extend it to group anagrams
• Reverse a string and an array with two pointers and no built-ins, then solve first non-repeating character with a frequency count
• Re-solve one of the three in a plain editor while narrating, as a screen-share rehearsal

Deliverable: Five working solutions with test cases for empty and single-element input, and notes from one narrated run.

Day 4 — Patterns and SQL

• Write the spaces-and-stars table, then code a pyramid, inverted pyramid and diamond, and test n = 0, 1 and 5
• Write the Nth-highest-salary query with DENSE_RANK, with DISTINCT and OFFSET returning NULL, and with the correlated COUNT, then the per-department version
• Run EXPLAIN on a slow query of your own and write which index would fix it
• Solve the soft-deleted accounts SQL practice question to rehearse a less familiar query shape

Deliverable: Three pattern programs, four salary queries tested on a table with ties, an annotated query plan, and the practice SQL solution.

Day 5 — Front-end frameworks

• Write a typeahead with debounceTime, distinctUntilChanged and switchMap, and convert one HttpClient call with firstValueFrom to compare it with a Promise
• Build a parent and child Angular component, log every lifecycle hook in order, then switch the child to OnPush and show that push() does not update it but a new array does
• If Lightning Web Components is on your resume, build a parent-child pair passing data down with @api and up with CustomEvent, and outline a pub-sub channel between unrelated components

Deliverable: A typeahead component, a lifecycle-logging demo with the OnPush experiment written up, and an optional LWC communication sketch.

Day 6 — Backend architecture

• Sketch a system split into services behind a gateway and write the monolith-versus-microservices answer, including saga, outbox and circuit breaker
• Write the load-balancing and session-management answer: L4 versus L7, algorithms, Redis session store versus JWT, and logout with tokens
• Sketch a real-time dashboard: SSE or WebSocket transport, heartbeat and backoff reconnect, snapshot plus deltas, pub-sub fan-out, client-side coalescing
• Work the listing-latency debugging practice question to rehearse a performance diagnosis aloud

Deliverable: Three architecture sketches with written answers and a debugging walkthrough.

Day 7 — Assessment rehearsal and HR stories

• Take a timed aptitude set and a short technical set covering OOP output prediction, one SQL query and one array problem
• Write and rehearse a five-sentence 'Tell me about yourself' and two resume project stories with architecture, your contribution and a measured result
• Rehearse the two behavioral practice questions on reversing a decision and handling callers you do not own
• List your questions for the HR/Managerial Round, including team stack and bond terms

Deliverable: A scored rehearsal set, a written introduction, two project stories, two behavioral answers and a question list.

Behavioural preparation

Candidates report the HR/Managerial Round covers cultural fit and expectations, with "Tell me about yourself" as the usual opener and detailed questions on the projects on your resume. For a role that works with client requirements and cross-functional teams, prepare stories that show what you built yourself, how you explained a technical decision to non-engineers, and how you handled something you did not know.

1. Tell me about yourself
2. Walk me through a project on your resume: its architecture, your specific contribution, and the hardest challenge you overcame.
3. Describe a time you were asked about a technology or problem outside your experience. How did you find the answer?
4. Tell me about a time you turned a vague business requirement into technical tasks. What did you clarify first?
5. Describe a code review disagreement you were part of and how it was settled.
6. Tell me about a performance or reliability problem you fixed, and how you proved the fix worked.

How do you handle load balancing and session management in backend systems?

Medium · System Architecture & Frameworks

Approach

1. Although filed with behavioral questions, this is a technical design question. Start with load balancing: Layer 4 (TCP, fast, content-blind) versus Layer 7 (HTTP, routes by path or header, terminates TLS), and the algorithms: round robin, weighted round robin, least connections, and IP hash or consistent hashing.
2. Explain health checks: active probes on a health endpoint remove a failing instance from rotation; pair them with connection draining so in-flight requests finish during deploys.
3. Session management options: sticky sessions (simple but uneven load, and sessions are lost when a node dies), a shared session store such as Redis keyed by session ID (servers stay stateless), or stateless tokens such as JWTs signed by the server.
4. State the token trade-off: JWTs avoid a store lookup but cannot be revoked before expiry, so use short-lived access tokens with refresh tokens, and a denylist or token-version check for logout and password change.
5. Mention security details: HttpOnly, Secure and SameSite cookie flags, session ID rotation on login to prevent fixation, and idle plus absolute timeouts.

Follow-up

• How do you log a user out everywhere when you use JWTs?
• How do WebSocket connections behave behind a load balancer, and what changes in your design?
• One instance is healthy but slow: how does least connections compare to round robin here?

Reverse your own decision and price the reversal

Medium · reversibility · measurement · migrations

Describe a technical decision you made and later reversed. Pick one that cost something: a service you split and merged back, a cache you added and removed, an index you created that pushed the planner onto a worse plan, a projection you rebuilt from scratch. State what you believed when you decided, the measurement that changed your mind, how long the wrong version ran in production, and what the reversal cost in migrations, dual writes, and a deprecation window for callers you did not own.

Approach

1. State the original rationale without irony, in the version you would still defend given what was known then. If it is not defensible, the story is about carelessness rather than judgement, and a different example serves you better.
2. Give the measurement that moved with a before and after: the p99 that did not improve, the cache hit rate that sat at 40%, the plan that flipped to a sequential scan once the table passed a size you can name.
3. Cost the reversal in steps, not adjectives: expand-and-contract deploys, the dual-write window, the callers who had to be notified, the rows already written in the wrong shape that had to be backfilled or abandoned.
4. Distinguish reversal from rewrite by naming what you kept. Most good reversals preserve the schema or the interface and undo one decision inside it, which is also why they were affordable.

Follow-up

• What in that decision was irreversible, and did you know it was irreversible when you made it?
• How did you tell the people who had already built on top of the original decision?

Tell callers you do not own that their integration breaks

Medium · deprecation · compatibility · stakeholders

A field in a write endpoint's response must change shape. You own the endpoint; you do not own the four internal callers or the outbound webhook consumers who read it. Describe a deprecation you were responsible for: what you shipped first, how you established who was actually reading the field, the window you gave and what set its length, what you did about the consumer who never moved, and how you decided removal was safe. Name the signal you used, not the announcement you sent.

Approach

1. Establish the reader set empirically rather than from a wiki of owners: per-field usage counters keyed by principal, or access logs attributed to a consumer. State the blind spot of whichever you pick, since a consumer that reads the field only on a monthly job will not appear in a week of logs.
2. Ship additive first. Populate the new field alongside the old one so no reader is forced to move, which is also what keeps a rolling deploy safe, because old and new instances answer the same requests at the same time and a rollback must still find the old shape present.
3. Set the window from the slowest legitimate consumer's release cadence, not from your calendar, and decide separately what to do for a consumer with no release process at all, such as an external webhook endpoint you can only email.
4. Convert silence into evidence before you rely on it: a short, low-traffic removal window that makes a still-dependent consumer fail visibly and loudly while you are watching, rather than at three in the morning after you have moved on.

Follow-up

• How would you detect a consumer that reads the field only during a monthly export?
• One caller refuses to move and has a commercial relationship behind it. What changes in your plan and what does not?