The reported questions cluster into two layers. The first is Java and web fundamentals: how ArrayList and LinkedList differ, how memory is managed in Java, what makes a web service RESTful, which design patterns you have used, and which data structures you have used and why. The second is classic exercises: reversing a linked list, binary search, finding two numbers that add up to a target, implementing a stack with queues, and explaining the time complexity of whatever you wrote.
Candidates also report scenario questions: designing a system for millions of users, describing how you debug, optimizing an existing application, presenting a solution to a hypothetical client feature request, and judging whether a software project succeeded. These are open-ended, so they reward a repeatable structure you can apply to any scenario rather than memorized answers.
The requirements candidates describe are Java, RESTful services, data structures and algorithms, and Git, and the duties include code review and defect fixing. That points your preparation at writing correct Java by hand, explaining trade-offs aloud, and telling stories where you made the decision. Because the reported material is broad but basic, depth on fundamentals (why, not just what) separates a solid answer from a recited one.
Initial Screening
reportedCandidates report that this first stage is a recruiter review of your resume and background to judge fit for the role. Nothing more specific is reported about format, so treat it as a conversation about your own history. Prepare a short, honest walkthrough of your career that foregrounds the stack the role lists (Java, RESTful web services, Git), and be ready to discuss any item on your resume in detail, because anything you list can become a follow-up. Ask the recruiter how many technical sessions to expect and what they cover.
What to demonstrate
- How your experience lines up with the listed requirements: Java, RESTful web services, data structures and algorithms, Git
- How clearly you describe your own past work
- Practical fit questions such as availability and location
How to prepare
- Write a walkthrough of your resume that names, for each job or project, the Java or web-service work you personally did
- Pick one project where you used REST and one where you used Git in a team workflow, and be ready to give specifics for each
- Prepare questions for the recruiter: number of technical interviews, which topics they cover, and what the remaining stages involve
Technical Interviews
reportedCandidates report one or more technical interviews covering coding, algorithms and system design. The reported questions that fit this stage by type are the coding exercises (reverse a linked list, binary search, two numbers summing to a target, a stack built from queues, explaining complexity), the Java and REST fundamentals, and the scenario questions on scaling, debugging and performance. Approach it by thinking aloud: restate the problem, give a simple solution first, then improve it, and state time and space cost without being asked.
What to demonstrate
- Working code on classic data structure and algorithm problems, with correct complexity analysis
- Java fundamentals such as collections, memory management and design patterns
- Understanding of RESTful web services and how you would structure a scalable system
- A repeatable approach to debugging and performance problems
How to prepare
- Write the linked-list reversal, binary search, two-sum and stack-from-queues solutions in Java without an IDE, then state the complexity of each
- Rehearse crisp explanations of ArrayList versus LinkedList, Java heap and garbage collection, and REST constraints
- Practice a scale-design outline: requirements, API, data store, caching, load balancing, failure handling
- Prepare a debugging sequence you can narrate: reproduce, narrow, form a hypothesis, fix, add a regression test
Behavioral Interviews
reportedCandidates report behavioral interviews that explore interpersonal skills and cultural fit. The reported prompts are about a challenging project, prioritizing under multiple deadlines, handling a team conflict, what motivates you, and staying current with technology. Approach it with a small set of real stories, each structured as situation, task, action, result, and chosen so that one story can answer several prompts. Say what you decided and did, not what the team did.
What to demonstrate
- How you describe collaboration, conflict and communication in your own past work
- Whether your examples show your own decisions and results
- How you handle competing priorities and keep learning
How to prepare
- Write three stories (a hard project, a disagreement, a deadline crunch) with the decision you made and a concrete outcome for each
- Map each story to the five reported prompts so you know which one answers which
- Prepare a specific, truthful answer for what motivates you and for how you keep up with Java and web technology
- Prepare questions for the interviewers about team structure, code review practice and how requirements reach engineers
PracHub editorial advice for the preparation topics above.
Reversing a linked list and losing the rest of the list because the next pointer was overwritten before it was saved
Keep three references (previous, current, next), save next before changing current's link, and trace a one-node list, an empty list and a three-node list by hand before you say you are done.
Describing ArrayList versus LinkedList as 'one is fast at insertion' without mentioning the cost of reaching the position
Explain that ArrayList is a resizable array with constant-time index access and amortized constant append, while LinkedList needs a traversal to reach a middle position, so inserting there is still linear. Add that cache locality makes ArrayList the default.
Answering the Java memory question with 'the garbage collector handles it'
Separate the heap, which holds objects, from thread stacks, which hold frames and references. Explain that objects become collectable when unreachable, and name a leak you could cause, such as a static collection that keeps growing.
Writing a binary search with an off-by-one error or an infinite loop, then stating the wrong complexity for the two-sum or stack-from-queues solutions
Fix your loop invariant (low, high, and what each bound means), compute mid as low plus half the difference, and test with one element and a missing target. Say the cost of each operation explicitly: logarithmic for binary search, linear with a hash map for two-sum.
Behavioral stories told as 'we did' with no personal decision and no measurable result
For each story, write the one decision you made and the outcome in a figure or concrete fact. Rehearse it aloud in first person, and keep the situation to two sentences.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
How do you manage memory in Java?
How do you manage memory in Java?
Approach
- Split stack and heap: each thread's stack holds frames with local primitives and references; objects live on the shared heap. Class metadata sits in Metaspace (which replaced PermGen in Java 8).
- Explain garbage collection by reachability from GC roots (thread stacks, static fields, JNI references), so unreachable cycles are collected. Generational heap: new objects in eden, survivors copied, long-lived objects promoted to the old generation. G1 is the default collector since JDK 9.
- A Java leak is unintended reachability: static collections or caches with no eviction, listeners never removed, ThreadLocal values left in pooled threads. Close non-memory resources with try-with-resources; finalize is deprecated and System.gc() is only a hint.
- Tooling: size with -Xms/-Xmx (and -Xss for stacks), enable -XX:+HeapDumpOnOutOfMemoryError, read GC logs (-Xlog:gc), and analyse a heap dump in Eclipse MAT or VisualVM by dominator tree / retained size.
- Mention reference types: WeakReference and WeakHashMap let entries go once the key is unreachable elsewhere; SoftReference is cleared under memory pressure.
Follow-up
- What is the difference between StackOverflowError and OutOfMemoryError: Java heap space, and what typically causes each?
- Heap usage climbs steadily in a running service. Walk through how you find the leak.
- Why can a ThreadLocal leak memory in an application server or thread pool?
Write a function to reverse a linked list.
Write a function to reverse a linked list.
Approach
- Iterative three-pointer solution: prev = null, curr = head; while curr != null: next = curr.next; curr.next = prev; prev = curr; curr = next; return prev as the new head.
- Complexity: O(n) time and O(1) extra space, since each node's pointer is flipped exactly once.
- Recursive version: reverse the rest, then head.next.next = head and head.next = null; it is O(n) time but O(n) call-stack space, so a long list can throw StackOverflowError in Java.
- Edge cases to test aloud: empty list, one node, two nodes, and confirming the old head's next is null so no cycle is left behind.
- Trace a three-node list on paper before running it; saving next before overwriting curr.next is the step most bugs miss.
Follow-up
- Reverse only the nodes between positions left and right in a single pass.
- Reverse the list in groups of k, leaving a short final group as it is.
- Check whether a linked list is a palindrome using O(1) extra space.
How would you implement a binary search algorithm?
How would you implement a binary search algorithm?
Approach
- State the precondition: the array is sorted (or the predicate is monotonic). Iterative form: lo = 0, hi = n - 1; while lo <= hi, compare a[mid] with the target and move lo = mid + 1 or hi = mid - 1; return -1 if not found.
- Compute mid as lo + (hi - lo) / 2 or (lo + hi) >>> 1; plain (lo + hi) / 2 can overflow int on very large arrays, a bug that once shipped in the JDK.
- Complexity: O(log n) time because the range halves each step (n / 2^k = 1 gives k = log2 n), and O(1) space iteratively versus O(log n) stack recursively.
- For duplicates, write the lower-bound variant: half-open [lo, hi), while lo < hi, hi = mid when a[mid] >= target; this returns the first index not less than the target and cannot loop forever.
- Edge cases: empty array, single element, target below the first or above the last element. Java's Arrays.binarySearch returns -(insertionPoint) - 1 when absent and does not guarantee which duplicate it finds.
Follow-up
- Find the first and last positions of a target in a sorted array with duplicates.
- Search for a target in a rotated sorted array in O(log n).
- Use binary search on the answer, for example the integer square root of x or the minimum capacity to ship packages within d days.
Given an array of integers, find two numbers such that they add up to a specific target.
Given an array of integers, find two numbers such that they add up to a specific target.
Approach
- Clarify first: return indices or values, exactly one solution or possibly none, can the same element be used twice, and are negatives allowed.
- Brute force: check every pair with nested loops, O(n^2) time and O(1) space.
- Optimal single pass with a HashMap from value to index: for each i, compute target - nums[i]; if it is in the map, return both indices; otherwise put nums[i] -> i. Checking before inserting stops an element pairing with itself and still handles [3, 3] with target 6.
- Complexity: O(n) time on average and O(n) space. If the array is already sorted, two pointers from both ends give O(n) time and O(1) space; sorting first costs O(n log n) and loses original indices unless you sort index pairs.
- Edge cases: fewer than two elements, no valid pair (return an empty array or throw, as agreed), and int overflow in target - nums[i] at extreme values (use long).
Follow-up
- Return all unique pairs that sum to the target, with no duplicate pairs.
- Extend it to three numbers summing to zero. What complexity can you reach?
- Numbers arrive as a stream and you must answer whether any pair sums to the target at any moment. What do you store?
Explain the time complexity of your solution.
Explain the time complexity of your solution.
Approach
- Count the dominant operation as a function of input size, drop constants and lower-order terms, and give space separately, including the recursion stack and any output you build.
- Distinguish best, average, worst and amortized: HashMap get/put is O(1) on average but degrades on collisions; ArrayList add is amortized O(1) because occasional O(n) copies are spread over many cheap appends.
- Derive rather than recite: binary search is O(log n) because the range halves each step; merge sort's recurrence T(n) = 2T(n/2) + O(n) gives O(n log n).
- Know the library costs you call: Collections.sort and Arrays.sort on objects use TimSort (stable, O(n log n) worst case, close to O(n) on already sorted input); list.contains inside a loop is O(n * m); repeated String concatenation in a loop copies characters each time, so use StringBuilder.
- Apply it to your own solution: for two-sum, say O(n) time and O(n) space against the O(n^2), O(1) brute force, and name the time-for-space trade.
Follow-up
- What does amortized O(1) mean, and why is ArrayList.add amortized constant rather than always constant?
- Can you reduce the space of your solution, and what would it cost in time?
- What is the worst case for HashMap lookups, and what changed in Java 8 to bound it?
Implement a stack using queues.
Implement a stack using queues.
Approach
- Restrict yourself to queue operations only: offer, poll, peek, size and isEmpty (an ArrayDeque or LinkedList used through the Queue interface).
- One-queue version: push(x) offers x, then rotates the previous size - 1 elements (poll then offer) so x sits at the front; pop is poll and top is peek. Push is O(n), pop and top are O(1).
- Two-queue version: push offers into q1 in O(1); pop moves all but the last element to q2, polls the last, then swaps the queues, so pop is O(n).
- Pick the version by the workload: push-heavy favours O(1) push, pop- or top-heavy favours the rotating single queue; both use O(n) space.
- Define empty behaviour: Queue.poll returns null and remove throws NoSuchElementException, so decide whether pop on an empty stack throws (for example EmptyStackException) and test it.
Follow-up
- Now implement a queue using two stacks and show why its operations are amortized O(1).
- Add a getMin operation that runs in O(1) to your stack.
- Which of your two versions would you choose for a workload of mostly pushes and rare pops, and why?
Explain why the owner filter ignores the listing index
The only index on resource is (tenant_id, status, updated_at DESC, resource_id DESC). A new endpoint returns one user's resources across all statuses, newest created first: WHERE tenant_id = $1 AND owner_user_id = $2 ORDER BY created_at DESC LIMIT 20. On a tenant with 2M rows it takes 900 ms and EXPLAIN shows a sort above a large scan. Explain precisely why the existing index cannot serve it, give the index that can, and state which of these the new index still will not help: owner_user_id alone across tenants; the same query ordered by updated_at. PostgreSQL 16.
Approach
- Separate the two jobs an index does. For filtering, a composite btree is seekable only on a left prefix, so with no predicate on status the scan can at best range over tenant_id and test owner_user_id per row; PostgreSQL 16 has no btree skip scan to jump the unconstrained column.
- For ordering, the index is sorted by (status, updated_at) within a tenant and not by created_at, so the LIMIT cannot stop early: every matching row is read and then sorted. That is the 'Sort Method: top-N heapsort' line, and it is why the plan reads 2M rows to answer with 20.
- Derive the replacement from the access path — equality, equality, then the ordering column: CREATE INDEX CONCURRENTLY ON resource (tenant_id, owner_user_id, created_at DESC). The scan seeks to the (tenant, owner) range and walks 20 entries in order, so the Sort node disappears along with the row-read.
- Treat INCLUDE (title, status) as conditional, not free. An index-only scan still visits the heap for any row whose page is not marked all-visible, so on a table taking 1.2k writes/second the win depends on autovacuum keeping the visibility map current, and the wider index costs more on every insert.
Follow-up
- 90% of rows are status='active'. Would a partial index WHERE status = 'active' change your answer, and for which of the three queries?
- A dashboard runs this for 40 owners in one page load. What changes about the design?
Stop tag and share joins from fanning out a page
resource_tag is (resource_id, tag_id) with PK (resource_id, tag_id); resource_share is (resource_id, shared_with_user_id, permission). The tagged-and-shared listing inner-joins resource to both, filters tenant_id, tag_id = ANY($2) and shared_with_user_id = $3, orders by updated_at DESC and takes 50. Pages come back with fewer than 50 distinct resources and the total in the header is far too high. Explain the row multiplication, rewrite both the page query and the count query so each is correct, and name the index each one needs. PostgreSQL 16.
Approach
- Do the arithmetic against the predicates that are actually there. An inner join emits one row per matching child row, and both joins are filtered: tag_id = ANY($2) admits only the requested tags, shared_with_user_id = $3 admits one user's share rows. So a resource holding three of the requested tags and shared with $3 once yields three rows, not one — the multiplier is its count of matching tags times its share rows for that single user, and that second factor is 1 unless the table admits duplicate (resource_id, shared_with_user_id) pairs. LIMIT 50 then limits rows rather than resources, and COUNT(*) counts pairs — the header is the product, not the population.
- Reject DISTINCT as the fix. It deduplicates after the product has been built, so the planner must materialise and sort the fanned-out set before the LIMIT can apply, and it leaves any SUM or AVG in the same select list wrong.
- Rewrite both filters as semi-joins, keeping resource as the only row source: AND EXISTS (SELECT 1 FROM resource_tag rt WHERE rt.resource_id = r.resource_id AND rt.tag_id = ANY($2)) and the same shape against resource_share. A semi-join stops at the first match per resource and preserves the driving index order, so ORDER BY updated_at DESC, resource_id DESC LIMIT 50 still stops after 50 rows.
- Count with the same predicates and no join at all: SELECT count(*) FROM resource r WHERE r.tenant_id = $1 AND r.status = 'active' AND EXISTS (...) AND EXISTS (...). Nothing multiplies a resource, so the number is the population.
Follow-up
- The filter changes from 'any of these tags' to 'all of these tags'. Rewrite it and state what it costs relative to the ANY form.
- A resource can be shared with the same user twice under different permissions. Does your count change, and should it?
What is the difference between an ArrayList and a LinkedList?
What is the difference between an ArrayList and a LinkedList?
Approach
- ArrayList wraps a resizable Object[]: get/set are O(1), add at the end is amortized O(1) (capacity grows by about 1.5x and the array is copied), and insert/remove in the middle is O(n) because System.arraycopy shifts the tail.
- LinkedList is a doubly linked list implementing both List and Deque: add/remove at either end is O(1), but get(i) is O(n) because it walks from the nearer end.
- Correct the usual myth: a middle insert in LinkedList is O(1) only once a ListIterator already sits at that position; finding the position is still O(n).
- Memory and locality: each LinkedList node is a separate object with item, next and prev references plus a header, scattered on the heap, so iteration is slower in practice; ArrayList may hold unused capacity (trimToSize releases it).
- Conclusion: ArrayList is the default; for a queue or stack, ArrayDeque usually beats LinkedList. Neither is synchronized, and both have fail-fast iterators that throw ConcurrentModificationException.
Follow-up
- Why is ArrayDeque generally preferred over LinkedList as a queue, and what can LinkedList store that ArrayDeque cannot?
- How do you remove elements matching a condition while iterating without a ConcurrentModificationException?
- What does ensureCapacity buy you when you know the final size up front?
Explain the concept of RESTful web services.
Explain the concept of RESTful web services.
Approach
- Define it by its constraints: resources named by URIs, a uniform interface over HTTP methods, stateless requests (each carries its own auth, such as a bearer token), cacheable responses, and a client-server split.
- Map methods to semantics: GET is safe and idempotent; PUT and DELETE are idempotent; POST is not; PATCH is not guaranteed idempotent. Use plural nouns (/orders/42), not verbs, in paths.
- Use status codes precisely: 201 Created with a Location header, 204 No Content, 400 vs 422 for bad input, 401 (not authenticated) vs 403 (not allowed), 404, 409 conflict, 429 rate limited.
- Cover the practical parts: JSON representations with content negotiation via Accept, ETag plus If-None-Match returning 304, pagination (cursor beats offset on large tables), and versioning in the path or a header.
- Contrast with SOAP: an XML envelope with a WSDL contract and WS-* standards, usually POSTed to one endpoint; in Java, mention the framework you have used (JAX-RS or Spring annotations) to build an endpoint.
Follow-up
- A client retries a POST that creates a payment after a timeout. How do you stop a double charge?
- When would you still pick SOAP or another RPC style over REST?
- How would you introduce a breaking change to a response without breaking existing clients?
Describe the various data structures you have used and their applications.
Describe the various data structures you have used and their applications.
Approach
- Organise the answer by access pattern, and give one real use from your own work for each structure plus why it fit.
- Hash-based: HashMap/HashSet give O(1) average lookup for dedup, counting and joins in memory; keys need consistent equals/hashCode and must not be mutated. Since Java 8, a crowded bucket becomes a tree, bounding it at O(log n).
- Ordered: TreeMap (red-black tree) gives O(log n) operations plus floorKey, ceilingKey and subMap for range queries; PriorityQueue (binary heap) gives O(log n) offer/poll and O(1) peek, used for top-k or scheduling.
- Sequential: ArrayList for indexed access, ArrayDeque as a stack or as the BFS queue; LinkedHashMap with accessOrder=true and removeEldestEntry gives an LRU cache.
- Beyond the collections: adjacency lists for graphs, a trie for prefix search or autocomplete; state the trade-off you accepted (memory for speed, ordering for constant-time lookup).
Follow-up
- How does HashMap handle collisions and resizing, and what is its worst case?
- Design an LRU cache with O(1) get and put. Which structures do you combine?
- When would you choose TreeMap over HashMap despite the slower lookups?
What are some design patterns you are familiar with?
What are some design patterns you are familiar with?
Approach
- Pick three or four patterns you have actually applied and give each its intent, where you used it and what it cost; a list of names without context is weak.
- Creational: Builder for objects with many optional fields; Factory Method to hide which implementation is created; Singleton, preferably as an enum or a lazy holder class, while naming its drawbacks (global state, hard to mock).
- Structural: Adapter to fit a third-party API to your interface; Decorator, as in java.io where BufferedInputStream wraps an InputStream; Proxy for lazy loading, access control or remote calls.
- Behavioral: Strategy (a Comparator passed to a sort), Observer (event listeners, publish-subscribe), Template Method (fixed algorithm skeleton with overridable steps).
- Close with judgment: a pattern adds indirection, so it pays only when the variation it isolates really exists; dependency injection often replaces hand-written singletons and factories.
Follow-up
- Write a thread-safe lazy singleton. Why does double-checked locking need the field to be volatile?
- What is the difference between Decorator and Proxy when both wrap an object?
- How do Strategy and State differ, given their class diagrams look alike?
How would you design a system that scales to handle millions of users?
How would you design a system that scales to handle millions of users?
Approach
- Pin the product and numbers before drawing: what the system does, daily active users, read/write ratio, latency target. Back-of-envelope: 100 million requests a day is about 1,160 per second on average (100M / 86,400), with peak several times that.
- Stateless application servers behind a load balancer so they scale horizontally; sessions in signed tokens or a shared store, not server memory.
- Reads: a CDN for static content, then a cache-aside layer (Redis or Memcached) with TTLs for hot data; name your invalidation rule on writes.
- Data: a primary with read replicas first (be explicit about replication lag and read-your-writes), then sharding by a key such as user_id with consistent hashing; choose SQL or NoSQL from the access pattern, not fashion.
- Move slow work (emails, fan-out, reports) onto a message queue with idempotent consumers; add timeouts, retries with backoff, circuit breakers, rate limiting, multi-zone deployment, and p99 latency and error-rate dashboards.
Follow-up
- One celebrity account or hot key receives most of the traffic. What breaks and how do you spread the load?
- The primary database fails. How does failover work and what data can you lose?
- How do you keep the cache consistent with the database when the same record is updated concurrently?
How would you approach optimizing an existing application for performance?
How would you approach optimizing an existing application for performance?
Approach
- Define the target and baseline first: which metric (p95/p99 latency, throughput, memory, startup time), under what realistic load, and what number counts as done.
- Profile before changing anything: distributed traces or APM to see where request time goes (database, downstream calls, CPU, GC), then a JVM profiler such as Java Flight Recorder or async-profiler for hot methods and allocation.
- Fix in order of likely payoff: database first (N+1 queries, missing indexes checked with EXPLAIN, selecting fewer columns, pagination), then caching, then algorithmic fixes (a HashMap instead of repeated list scans), then I/O (batching, connection pooling).
- Change one thing at a time and re-measure with a load test (JMeter or Gatling); for microbenchmarks use JMH, because JIT warm-up makes naive timing misleading.
- State the trade-offs: caches add staleness and invalidation work, async adds complexity; Amdahl's law caps the overall gain by the share of time the optimised part takes.
Follow-up
- Average latency is fine but p99 is very high. What causes would you suspect?
- How do you tell a real improvement from measurement noise?
- After you added a cache, users see stale data. How do you fix it without losing the speed-up?
Present a solution for a hypothetical feature request from a client.
Present a solution for a hypothetical feature request from a client.
Approach
- Find the problem behind the request: who uses it, in which workflow, what success looks like for the client, and the constraints (deadline, budget, compliance, expected volume).
- Restate it as user stories with acceptance criteria, then split a minimal first release from later phases so scope is explicit.
- Outline the design concretely: data model changes, REST endpoints with methods and status codes, UI touchpoints, backward compatibility for existing clients. For example, a large report export becomes POST /exports returning 202 with a job id, a background worker, and GET /exports/{id} for status and download.
- Plan delivery: estimate, main risks, unit and integration tests, rollout behind a feature flag, and the metric that shows the feature is used.
- Offer the client options with costs (a simple version now versus a fuller one later) and say which you recommend and why.
Follow-up
- The client needs it in half the time. What do you cut, and how do you explain it?
- The requirement changes after you have started building. How do you handle it?
- How would you roll this out without breaking clients already using the existing API?
Discuss how you would evaluate the success of a software project.
Discuss how you would evaluate the success of a software project.
Approach
- Agree on success criteria before the work starts, tied to user or business outcomes (adoption, task completion, fewer support tickets, revenue), not output such as lines of code or story points.
- Measure delivery and quality separately: on time and in scope, escaped defects, incidents, availability against an SLO, p95 latency.
- For engineering health, cite the DORA metrics: deployment frequency, lead time for changes, change failure rate and time to restore service.
- Compare against a baseline and be careful with attribution: a before/after comparison can be confounded by seasonality or other launches, so use a control group or staged rollout when you can.
- Add qualitative input (user and stakeholder feedback, maintainability) and close with a retrospective on what to keep and change; illustrate with a project of your own.
Follow-up
- The project shipped on time and on budget, but almost nobody uses the feature. Was it a success?
- Two of your metrics conflict, for example faster delivery but more incidents. How do you weigh them?
- How would you measure the success of a project you worked on that had no metrics defined up front?
Describe your process for debugging a software issue.
Describe your process for debugging a software issue.
Approach
- Reproduce first: exact input, environment, version and frequency; capture it as a failing automated test where possible so the fix is provable.
- Gather evidence before theorising: read the stack trace down to the innermost Caused by, check logs and metrics around the first failure, and list what changed (commits, deploys, config, data, dependency versions).
- Narrow the search space by halving: git bisect across commits, toggling half the code path or config, then a debugger with conditional breakpoints or targeted logging at the boundary where data turns wrong.
- For intermittent or production-only issues, think concurrency, timing and environment: take thread dumps (jstack) for deadlocks or contention, a heap dump for memory, and compare configuration between environments.
- Fix the root cause rather than the symptom, add the regression test, verify in a production-like environment, and write a short note on cause and prevention; anchor the answer in one real bug you solved.
Follow-up
- The bug occurs only in production and you cannot attach a debugger. What do you do?
- A test fails roughly once in a hundred runs. How do you track it down?
- How do you show the fix addressed the cause and not a coincidence?
The plan follows the reported loop: the screening conversation first, then Java fundamentals, the four coding exercises, REST and scale design, debugging and scenario questions, and finally behavioral stories. Each day names the reported questions it practises.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the loop and shape your resume story
- Write the order of the reported stages (Initial Screening, Technical Interviews, Behavioral Interviews) and note what each needs from you
- Write a resume walkthrough that names, for each role, your own Java, REST and Git work
- List the listed requirements (Java, RESTful services, data structures, Git) and mark each with one real example you can discuss
Deliverable: A one-page stage map, a written resume walkthrough, and a requirements-to-example table with the weakest row marked.
02Java collections, memory and design patterns
- Write a short comparison of ArrayList and LinkedList with the cost of index access, append, middle insert and iteration
- Draw the Java heap and stack, and write how objects become eligible for garbage collection plus one example of a memory leak
- List four design patterns you have actually used (for example singleton, factory, observer, strategy) with the code situation for each
Deliverable: A collections comparison sheet, a heap and stack diagram with a leak example, and four pattern examples from your own code.
Practice prompt ↗Practice prompt ↗Practice prompt ↗03Linked list, binary search and stack from queues in Java
- Write the iterative linked-list reversal in Java and test it on empty, single-node and longer lists
- Write binary search with a clear invariant and test it with a missing target and a single element
- Implement a stack with two queues, then with one queue, and state the cost of push and pop in each version
Deliverable: Three working Java solutions with test cases and a complexity note for each.
Practice prompt ↗Practice prompt ↗Practice prompt ↗04Two-sum, complexity narration and data structure inventory
- Solve the two-number target problem by brute force, then with a hash map, and say the time and space cost of both
- Pick three earlier solutions and record yourself explaining their time and space complexity aloud
- Write a list of data structures you have used on real work with the problem each solved
Deliverable: A two-sum solution in both forms, three recorded complexity explanations, and a data-structure inventory tied to your projects.
Practice prompt ↗Practice prompt ↗Practice prompt ↗05RESTful services and scalable design
- Write a one-page summary of REST (resources, HTTP methods, status codes, statelessness) and a short contrast with SOAP
- Design a simple resource API in outline, including paths, methods and error responses
- Outline a system for millions of users: load balancing, caching, read and write paths, data partitioning and failure handling
Deliverable: A REST summary with a SOAP contrast, an outlined resource API, and a one-page scale design with the first bottleneck marked.
Practice prompt ↗Practice prompt ↗06Debugging, performance and client scenarios
- Write your debugging sequence and apply it to a real past bug, from reproduction to regression test
- Write a performance plan for an existing application: measure, profile, fix the biggest cost, re-measure
- Outline how you would answer a client feature request: clarify needs, scope, a first version, risks
- Write the measures you would use to judge a finished project's success
Deliverable: A debugging checklist with one worked bug, a performance plan, a client-request outline and a list of success measures.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗07Behavioral stories out loud
- Write three STAR stories (hard project, team conflict, competing deadlines) with your decision and result in each
- Answer each reported behavioral prompt aloud and record it, then cut any 'we' that hides your own action
- Prepare a truthful answer on motivation and one on how you keep up with Java and web technology
Deliverable: Three written STAR stories, recorded spoken answers to the five reported prompts, and two short prepared answers.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Expand any day for tasks and deliverables. Your progress is saved on this device.
Candidates report behavioral interviews that explore interpersonal skills and cultural fit. The reported prompts cover a hard project, prioritizing deadlines, team conflict, motivation and staying current, so a few well-chosen stories of your own decisions and results go a long way. Keep each story in first person and finish it with a concrete outcome.
Describe a challenging project you worked on and how you approached it.
Describe a challenging project you worked on and how you approached it.
Approach
- Pick a project where you owned a real decision, such as a Java service redesign, a REST integration with unclear requirements, or a performance problem, rather than one where you only carried out tasks.
- Spend two sentences on context and name what made it hard: a constraint, ambiguity, a deadline or a technical unknown.
- Describe the options you weighed, why you picked one, and how you tested the choice before committing, for example a prototype or a measurement.
- Close with a concrete result (defect count, response time, delivery date, rework avoided) and one thing you would change.
- The mistake that sinks it is a story told entirely in terms of what the team did, or one that is hard only because of long hours.
Follow-up
- What option did you reject, and what would have made you choose it?
- How did you know the result came from your change?
- What would you do differently if you ran the project again?
How do you prioritize tasks when faced with multiple deadlines?
How do you prioritize tasks when faced with multiple deadlines?
Approach
- Give a method first: list each deadline with its date, the consequence of missing it, the effort left and any dependency on other people.
- Then show it in one real situation: who you asked to confirm priority, what you dropped or deferred, and how you told affected people early.
- Show negotiation of scope as well as ordering, for example agreeing a smaller first release with a product manager or client.
- If you track work in a backlog tool such as JIRA, say how you used it; otherwise describe your own system plainly.
- Avoid answers that amount to working longer hours or claiming everything gets done; these show no judgment.
Follow-up
- What if two stakeholders each insist their request comes first?
- What did you decide not to do, and what happened?
- How did you tell someone their deadline would slip?
Give an example of how you handled a conflict within a team.
Give an example of how you handled a conflict within a team.
Approach
- Choose a disagreement over something substantive, such as an API design choice, a code review comment or an estimate, not a personality clash where the other person is the villain.
- State the other person's position fairly, in words they would accept, before giving yours.
- Explain how you moved from opinion to evidence: a small benchmark, a prototype, a ticket history, or asking a tech lead or product manager to decide.
- Say what was decided and how you worked together afterward; a relationship that survived is part of the result.
- Do not tell a story in which you were simply right, and do not claim you have never had a conflict.
Follow-up
- What if the other person still disagreed after seeing the evidence?
- What did you learn about their reasoning that you had missed?
- How did your working relationship change afterward?
What motivates you to excel in your work?
What motivates you to excel in your work?
Approach
- Answer with two or three specific motivators, and back each with a moment from your work rather than an adjective like passion.
- Good, checkable examples for an engineer: tracing a defect to its root cause, seeing a shipped feature used, or mastering a harder part of Java or web services.
- Connect the motivator to the duties candidates describe for this role, such as building applications to client needs, reviewing code and fixing defects, without claiming anything about the company's values.
- Keep it short, around a minute spoken, then offer to go deeper on one example.
- Avoid answers about pay alone, or flattery of the company that you cannot support.
Follow-up
- What drains your motivation, and what have you done about it?
- Tell me about a time your motivation was low on a project.
- How does what motivates you show up in the way you work day to day?
How do you stay current with technological advancements?
How do you stay current with technological advancements?
Approach
- Name the actual sources and habits you use, such as Java release notes, official framework documentation, a newsletter or a conference talk, instead of a generic list.
- Add a practice habit: a small side project, for example a REST service or a data structure exercise, so learning is hands-on.
- Give one example where something you learned changed your work, such as adopting a library feature, fixing a pattern in code review, or trying a cloud service like AWS or Azure.
- Show selectivity: how you judge whether a new tool is worth adopting, for instance maturity, team familiarity and migration cost.
- The mistake is listing websites with no example of use, or implying you chase every new trend.
Follow-up
- What did you learn most recently, and where did you apply it?
- How do you decide whether a new technology is worth adopting on a project?
- Tell me about something you looked at and chose not to adopt.
- 01
Describe a challenging project you worked on and how you approached it.
- 02
How do you prioritize tasks when faced with multiple deadlines?
- 03
Give an example of how you handled a conflict within a team.
- 04
What motivates you to excel in your work?
- 05
How do you stay current with technological advancements?
- 06
Tell me about a time you found the cause of a defect that others had struggled with.
How many rounds are in the Bayone Solutions Software Engineer interview?
Candidates report three stages: an Initial Screening where recruiters review your resume and background, one or more Technical Interviews on coding, algorithms and system design, and Behavioral Interviews on interpersonal skills and cultural fit. The overall process is reported at about three to five weeks.
Bayone Solutions Software Engineer candidate reports ↗Which technologies should I be ready to discuss?
The requirements candidates describe list Java, RESTful web services, data structures and algorithms, and Git. Front-end basics (HTML, CSS, JavaScript), Agile practice with tools like JIRA, and cloud platforms such as AWS or Azure are listed as extras. Prepare Java in depth first and treat the extras as topics to mention honestly if you have used them.
Bayone Solutions Software Engineer candidate reports ↗How should I prepare for the system design part of the technical stage?
The reported scale question asks for a design that handles millions of users. Practice a fixed outline: clarify requirements, define the API, choose a data store, separate read and write paths, add caching and load balancing, and say what fails first under load. Keep the design simple and explain trade-offs aloud.
Bayone Solutions Software Engineer candidate reports ↗What is the difference between REST and SOAP, since both are reported as topics?
REST is an architectural style that uses resources identified by URLs, standard HTTP methods and status codes, and stateless requests, usually with JSON. SOAP is a protocol with an XML message envelope and a formal contract (WSDL), often paired with extra standards. A good answer names a case for each: REST for simple resource-oriented APIs, SOAP where a strict contract or built-in standards are required.
Bayone Solutions Software Engineer candidate reports ↗How long should I prepare, and is a one-week plan enough?
Candidates report spending about two to four weeks preparing. A one-week plan works if your Java and data structure basics are already solid: use it to drill the reported questions aloud and write the coding solutions by hand. If the basics are shaky, stretch the plan and spend extra days on days 2 to 4.
Bayone Solutions Software Engineer candidate reports ↗Is there a take-home assignment or a specific coding platform?
No take-home or platform is reported. Ask your recruiter during the screening about the format of the technical sessions, and practise writing Java without autocomplete in case the session uses a shared editor.
PracHub Software Engineer practice ↗Sources & methodology 3 sources ↗
No official company page is cited. Rounds and questions come from candidate reports and PracHub editorial material; each source shows the date it was read.
- 01Bayone Solutions Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
Candidate reports · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
PracHub page · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
PracHub page · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Confluent Software Engineer Interview Guide
Concurrency exercises for Confluent candidates: check-then-act races, deadlock from inconsistent lock ordering, and why two individually atomic operations do not compose into an atomic update.
GitHub Software Engineer Interview Questions & Guide 2026
Testing exercises for GitHub software engineer prep: choosing boundary cases over repetition, isolating tests from shared clock and ordering, and treating an intermittent failure as a defect rather than noise.
Zulily Software Engineer Interview Guide
What Zulily asks Software Engineer candidates, from reported rounds and questions.
Zoom Communications Software Engineer Interview Guide
What Zoom Communications asks Software Engineer candidates, from reported rounds and questions.