Aventior Software Engineer Interview Guide

The 60-second brief

Candidate reports describe the role more than the product. Software Engineers at Aventior are described as working across the whole development lifecycle, from first concept through deployment and later maintenance, alongside product management and quality assurance. The day-to-day duties candidates list are building features against business requirements, integrating applications with other teams, code review, and troubleshooting production issues. The stack in the requirements is Java (core and newer JDK features), Spring Boot, Hibernate, and SQL on MySQL. HTML, CSS, JavaScript, Agile practice and AWS or Azure appear as nice-to-haves.

This guide is for engineers interviewing for a Software Engineer position at Aventior who will be asked to show Java depth rather than general programming ability. It covers the four reported stages, all 25 reported questions (Java and OOP concepts, coding and dynamic programming, a duplicate-records SQL query, system and database design, debugging and performance cases, and behavioral prompts), and a seven-day plan that works through them in that order.

Candidates report four stages over roughly 3-5 weeks: Initial Screening, Technical Rounds, a Managerial Interview and an HR Interview, with salary expectations raised in the managerial conversation.

Focus areas

• Java
• Core Java
• Advanced Java (incl. modern/JDK features)

Overview

The reported questions lean heavily on Java itself. Five of them are concept questions (how Java compares with other languages, Java 8 features, OOP principles, exception handling, interfaces), and the topic areas candidates mention are Java, Core Java, newer JDK features, dynamic programming and Spring Boot. Expect to explain the language from the inside: what the JVM does, why checked exceptions exist, what changed when interfaces gained default methods. Memorised feature names will not carry you through a follow-up; a ten-line example of each will.

The coding questions are standard and small: reverse a linked list, check a string for unique characters, a Fibonacci-style dynamic programming problem, optimising an algorithm, and a SQL query for duplicate rows. Candidates are advised to be ready to code without an IDE, so the risk is less the algorithm and more writing compilable Java by hand: the Node class, generics, null checks, and the exact Collections API calls.

The design and case questions cover a range rather than one theme: a URL shortener, an e-commerce database schema, microservices, scalability considerations, data integrity across distributed services, debugging a complex issue, estimating a feature, and speeding up a slow application. Answer them in the stack the role lists. A schema answer that mentions Hibernate mappings and MySQL indexes, or a performance answer that names the N+1 query problem and connection-pool exhaustion, is far more concrete than a generic whiteboard diagram.

The last two stages are conversations. Candidates report the managerial interview covering past experience, aspirations and salary expectations, and the HR interview covering experience and fit with the team. Six reported behavioral prompts belong here, so prepare written stories in advance and know the salary range you will state.

The Aventior interview process

Candidates describe four stages, starting with a resume-focused screen and ending with managerial and HR conversations; the stage names below are the ones they report.

Initial Screening

Candidates report that the initial screen centres on the resume and general qualifications. Treat it as a check of whether your background matches the requirements listed for the role: Java, Spring Boot, Hibernate and SQL. For each project on your resume, be ready to say which of those you used, what you personally built, and one technical decision you made. If you have the nice-to-haves (front-end work, Agile teams, AWS or Azure), say where. Use the end of the call to confirm what the technical rounds involve.

What to demonstrate

• The projects and experience on your resume
• Fit between your background and the listed Java, Spring Boot, Hibernate and SQL requirements

How to prepare

• Write one line per resume project naming the Java version, frameworks and database used and the part you owned.
• Prepare a short, specific answer to why Aventior and why this role, built from the role's duties (lifecycle ownership, work with product and QA).
• Ask how many technical rounds to expect and whether coding happens in a plain editor or on paper.

Technical Rounds

Candidates report technical rounds that test coding, software engineering principles and problem solving; the name is plural, so plan for more than one session. Candidates are advised to practise coding without an IDE. The reported question list is where this stage's material comes from: Java concept questions, small algorithm problems, a SQL duplicates query, and design and debugging questions. Reports do not say which question lands in which session, so prepare all of them. When you code, state the approach and complexity first, then write complete Java including the class and method signatures, then walk an example and the edge cases by hand.

What to demonstrate

• Working Java code written without IDE support
• Java and OOP fundamentals, including newer JDK features
• Problem-solving approach on algorithm, SQL and design questions

How to prepare

• Hand-write the linked-list reversal, the unique-characters check and Fibonacci three ways (memoised, bottom-up, constant space) in a plain text editor, then compile them.
• Rehearse aloud the Java questions: language comparison, Java 8 features, OOP principles, exception handling, interfaces, each with a code example.
• Write the duplicate-records query with GROUP BY/HAVING and with ROW_NUMBER(), and know the MySQL 5.7 alternative.
• Revise Spring Boot and Hibernate basics: dependency injection, @Transactional rollback rules, lazy loading and the N+1 problem.

Managerial Interview

Candidates report a managerial interview about past experience, aspirations and salary expectations. Come with two or three project stories told at the level of decisions and outcomes, a clear statement of where you want your career to go over the next few years that connects to Java backend work, and a researched salary range. The reported behavioral prompts (a challenging project, prioritising across deadlines, collaboration, motivation, handling criticism, deciding with incomplete information) are the question types this kind of conversation covers.

What to demonstrate

• Depth and ownership in your past projects
• Career aspirations and how they fit the role
• Salary expectations

How to prepare

• Write STAR outlines for the challenging-project, prioritisation and incomplete-information prompts, each with a measurable result.
• Decide your salary range and notice period before the call and state them plainly when asked.
• Prepare one aspiration answer that names a skill you want to grow in this role, such as system design or cloud deployment.

HR Interview

Candidates report the HR interview as a further discussion of experience and of alignment with the team. Expect the motivation, collaboration and criticism style of prompt. Answers that hold up are short, specific stories with your own actions in them; a list of adjectives about yourself does not. Close with questions about the team you would join, its release process and how it works with QA and product.

What to demonstrate

• Consistency of your experience story across stages
• How you work with others and respond to feedback

How to prepare

• Rehearse the collaboration and criticism stories aloud, each with a concrete change you made afterwards.
• Prepare a motivation answer tied to a specific piece of work you enjoyed and why.
• Write three questions about the team's workflow with QA and product management.

Where candidates lose points

Writing Java that only works with IDE autocomplete: missing the ListNode class, wrong collection method names, unhandled nulls.

Since candidates are advised to code without an IDE, write the linked-list, unique-characters and Fibonacci solutions in a plain editor, compile them from the command line, and fix every error before the interview. Write the class and method signatures out every time.

Answering the Java 8 or interfaces question with a list of feature names and no example, or saying interfaces cannot contain method bodies.

Prepare one short code example per feature (a stream pipeline with groupingBy, a lambda for a Comparator, Optional on a repository return, a default method). Know that default and static interface methods exist since Java 8 and private ones since Java 9.

Returning only the duplicated key in the SQL duplicates question when the full rows or a deletion were wanted, or missing the NULL behaviour.

Ask whether the goal is to list keys, show full rows or delete extras. Prepare GROUP BY/HAVING, ROW_NUMBER() for MySQL 8, a self-join for older MySQL, and the delete-keeping-lowest-id variant, then explain how NULLs behave in each.

Treating every design question as a microservices diagram, with no numbers, no schema and no failure handling.

For the URL shortener, e-commerce schema, scalability and data-integrity questions, start with the requirements and rough numbers, write the table and its key, then add caching, replicas, idempotency or sagas only where the numbers or consistency needs call for them.

Reaching the managerial interview without a salary figure or an answer about aspirations.

Candidates report salary expectations being discussed there. Research a range for your level and location, decide your number and notice period, and prepare a short, specific answer about where you want your career to go.

Questions & practice

Write a function to reverse a linked list.

Medium · Coding / Algorithms

Approach

1. Write the iterative version with three references: prev = null, curr = head; loop: next = curr.next, curr.next = prev, prev = curr, curr = next; return prev.
2. State complexity: O(n) time, O(1) extra space.
3. Offer the recursive version (reverse the rest, then head.next.next = head; head.next = null) and note its O(n) call stack, which can overflow on long lists in Java.
4. Walk the edge cases by hand: empty list, one node, two nodes, and confirm the old head's next is null at the end.
5. Since you may code without an IDE, write the ListNode class and method signature out in full.

Follow-up

• Reverse only the nodes between positions m and n.
• Reverse the list in groups of k.
• Use reversal to check whether a linked list is a palindrome in O(1) extra space.

How would you determine if a string has all unique characters?

Medium · Coding / Algorithms

Approach

1. Clarify the character set and case sensitivity first; that decides the data structure.
2. Default answer: iterate and add to a HashSet<Character>, returning false when add() returns false; O(n) time, O(min(n, alphabet)) space.
3. For ASCII, use a boolean[128] and return false immediately if length exceeds 128 (pigeonhole); for lowercase letters only, a single int bitmask.
4. Without extra structures: sort the char array and compare neighbours in O(n log n), or compare all pairs in O(n^2).
5. For full Unicode, iterate s.codePoints() so surrogate pairs are not treated as two characters.

Follow-up

• Solve it without any additional data structure.
• Make the check case-insensitive and ignore spaces.
• Write it as a one-line stream expression and say what it costs.

Solve a problem related to dynamic programming (e.g., Fibonacci sequence).

Medium · Coding / Algorithms

Approach

1. Start from the recurrence F(n) = F(n-1) + F(n-2) and show why naive recursion is exponential: subproblems repeat.
2. Fix it top-down with memoisation (a long[] or HashMap cache, O(n) time and space), then bottom-up with a table, then with two variables for O(1) space.
3. Raise overflow: F(93) exceeds long, so use BigInteger or modular arithmetic if n is large.
4. Mention matrix exponentiation or fast doubling for O(log n).
5. Generalise the method for whatever DP problem replaces Fibonacci: define the state, the transition, the base cases and the fill order; climbing stairs and coin change follow the same pattern.

Follow-up

• Find the minimum number of coins to make an amount, and its complexity.
• How would you compute F(n) mod 1e9+7 for n around 10^18?
• Why can the memoised recursive version fail for large n in Java?

Explain how you would optimize a given algorithm.

Medium · Coding / Algorithms

Approach

1. Measure before changing anything: state the current time and space complexity and, for real code, profile to find where time actually goes.
2. Remove repeated work: memoise overlapping subproblems, precompute prefix sums, hoist invariant work out of loops.
3. Change the data structure to fit the access pattern: HashMap or HashSet lookups instead of List.contains (O(n) to O(1)), a PriorityQueue for top-k, sorting plus two pointers or binary search.
4. Use a concrete example such as two-sum: nested loops at O(n^2) become one pass with a HashMap at O(n), trading memory for time.
5. Mention Java constant factors: StringBuilder instead of string concatenation in loops, avoiding autoboxing in hot paths, sizing collections up front.

Follow-up

• When is the asymptotically better algorithm slower in practice?
• How do you confirm an optimisation helped rather than guessing?
• What would you do if the faster version needs more memory than you have?

Write a SQL query to find duplicate records in a table.

Medium · Coding / Algorithms

Approach

1. Clarify what makes two rows duplicates: all columns, or a business key such as email after trimming and lowercasing.
2. Basic query: SELECT email, COUNT() FROM users GROUP BY email HAVING COUNT() > 1, which lists the duplicated keys and their counts.
3. To return the full rows, use ROW_NUMBER() OVER (PARTITION BY email ORDER BY id) and keep rn > 1 (MySQL 8+), or join back to the grouped subquery; on MySQL 5.7 use a self-join on a.email = b.email AND a.id > b.id.
4. Watch NULLs: GROUP BY puts NULLs in one group, but an equality join never matches NULL to NULL, so the two methods can disagree.
5. Finish with prevention: delete the extras keeping the lowest id, then add a UNIQUE constraint; an index on the key column keeps the grouping cheap.

Follow-up

• Delete the duplicates in MySQL while keeping the earliest row of each group.
• How would you find duplicates defined across three columns?
• How does the query behave on a table of a hundred million rows, and what index helps?

Write the update path that detects a concurrent edit

Medium · optimistic concurrency · transactional outbox · audit history

resource carries version INT NOT NULL DEFAULT 1. resource_revision holds revision_id, resource_id, version, actor_user_id, change_kind, patch JSONB, request_id, created_at with UNIQUE (resource_id, version). outbox_event holds aggregate_type, aggregate_id, aggregate_version, event_type, payload, status. A PUT carries the version the client read. Write the exact statements for the single transaction that applies the edit, records the revision and enqueues 'resource.updated', and give the handler's branch on zero affected rows. Then say what PostgreSQL 16 does under READ COMMITTED when two of these updates hit one row at once.

Approach

1. One transaction, three writes, no network call inside it: UPDATE resource SET title = $3, version = version + 1, updated_at = now() WHERE resource_id = $1 AND tenant_id = $4 AND version = $2; then INSERT the resource_revision row at version $2 + 1; then INSERT the outbox_event row at the same aggregate_version. The event goes to a table rather than a broker because no transaction spans both.
2. Branch on the affected-row count before doing anything else. Zero has three causes — stale version, wrong tenant, row gone — so re-read once and map to 409 carrying the current version, or 404 for an id outside the caller's tenant, which also stops the endpoint confirming that another tenant's id exists.
3. State the engine behaviour instead of assuming it. Under READ COMMITTED the second UPDATE blocks on the row lock, and when the first commits PostgreSQL re-evaluates the WHERE clause against the newly committed row, so the version predicate now fails and the statement reports zero rows. Under REPEATABLE READ the identical collision raises SQLSTATE 40001 instead, so the handler must fold both shapes into one conflict response.
4. Keep UNIQUE (resource_id, version) even though the predicate already serialises writers. It is what makes a lost update unwritable if any other path ever reaches the revision table, and it converts a logic bug into 23505 rather than into a silently missing history row.

Follow-up

• A client sends the version it read ten minutes ago and the resource has moved three versions. What is in your 409 so it can resolve the conflict without a full re-fetch?
• Two editors, two disjoint fields, no overlap. Does your answer still refuse the second write, and should it?

Explain the differences between Java and other programming languages.

Medium · Technical / Domain Questions

Approach

1. Pick two or three named comparators (C++, Python, and C# or Kotlin) and compare on fixed axes instead of listing Java facts.
2. Execution: Java compiles to bytecode run on the JVM with JIT compilation, giving portability across platforms; C++ compiles to native code; CPython interprets bytecode with no JIT by default.
3. Memory and safety: Java has garbage collection and no pointer arithmetic, against C++ manual memory or RAII; Java is statically typed, Python dynamically typed.
4. Language design: single class inheritance with multiple interface inheritance, checked exceptions (rare among mainstream languages), primitives versus boxed types, and everything inside a class.
5. Close with a trade-off: verbosity and JVM startup cost against tooling, ecosystem (Spring, Hibernate) and stable performance for long-running services.

Follow-up

• How does JIT compilation differ from interpretation, and why do Java services warm up?
• Why does Java disallow multiple class inheritance, and how do default methods change that picture?
• Does Kotlin have checked exceptions, and what does that tell you about their cost?

What are the new features in Java 8?

Medium · Technical / Domain Questions

Approach

1. Lead with lambdas and functional interfaces (Function, Predicate, Supplier, Consumer, @FunctionalInterface), then method references such as String::toUpperCase.
2. Explain the Stream API: lazy intermediate operations (filter, map, flatMap, sorted) and terminal operations (collect, reduce, forEach), with an example like list.stream().filter(o -> o.getTotal() > 100).collect(Collectors.groupingBy(Order::getCustomerId)).
3. Cover default and static methods on interfaces, Optional for return values, the java.time API (immutable LocalDate, Instant, Duration replacing Date and Calendar), and CompletableFuture.
4. Mention the JVM change: PermGen replaced by Metaspace.
5. Show awareness of later releases since newer JDK features are a reported topic: var (10), records (16), sealed classes and pattern matching (17), virtual threads (21).

Follow-up

• What is the difference between map and flatMap on a stream?
• When does a parallel stream make code slower or incorrect?
• Why is using Optional as a field or method parameter discouraged?

Describe the principles of object-oriented programming.

Medium · Technical / Domain Questions

Approach

1. Name the four principles and give a Java example of each rather than a definition: encapsulation (private fields, validated setters), abstraction (an interface hiding implementation), inheritance (extends), polymorphism.
2. Split polymorphism into compile-time (method overloading) and runtime (overriding resolved by dynamic dispatch on the object's actual type).
3. Add composition over inheritance: inheritance couples a subclass to its parent's internals, composition lets you swap behaviour.
4. Link to SOLID briefly, and use Liskov substitution with the Square-extends-Rectangle example to show inheritance misused.

Follow-up

• What is the difference between overloading and overriding, and can you override a static method?
• When would you choose an abstract class over an interface?
• Show a class that breaks encapsulation and fix it.

What is the significance of interfaces in Java?

Medium · Technical / Domain Questions

Approach

1. Define an interface as a contract of behaviour separate from implementation, and give the payoff: callers depend on the type, not the class, so implementations can be swapped and mocked in tests.
2. Show it in Spring: inject a PaymentService interface and let configuration choose the implementation; Spring Data repositories are interfaces whose implementations are generated.
3. Cover the Java 8 and 9 additions: default and static methods (Java 8), private methods (Java 9), and functional interfaces as the target type for lambdas.
4. Contrast with abstract classes: interfaces have no instance state or constructors, and a class can implement many interfaces but extend one class.
5. Explain the default-method diamond: if two interfaces supply the same default, the class must override it and can call A.super.method().

Follow-up

• What is a marker interface, and what replaced most uses of them?
• How would you add a method to a widely implemented interface without breaking implementers?
• Why do Spring proxies work more simply when beans are injected by interface?

Design a URL shortening service like Bitly.

Medium · System Design / Architecture

Approach

1. Fix requirements: shorten a long URL, redirect from the short code, optional custom aliases and expiry, click analytics; note the system is read-heavy.
2. Key generation: base62-encode a unique numeric ID (7 characters give 62^7, about 3.5 trillion codes), with ID ranges handed out per app instance to avoid a single counter; or hash the URL and resolve collisions, which costs extra lookups.
3. Data and APIs: POST /shorten and GET /{code}; a table keyed by code with long_url, created_at, expires_at and owner; an index on long_url if the same URL should map to one code.
4. Read path: cache code-to-URL in an in-memory store in front of the database and keep the app tier stateless so it scales horizontally.
5. Redirect choice: 301 is cached by browsers and saves load but loses click counts; 302 keeps every click visible for analytics, recorded asynchronously through a queue.

Follow-up

• What happens when two users shorten the same long URL?
• How do you generate IDs across several instances without collisions?
• How would you block malicious or spam URLs?

How would you structure a database for an e-commerce application?

Medium · System Design / Architecture

Approach

1. List the core tables: users, addresses, products, categories, product variants or SKUs, inventory, carts and cart_items, orders and order_items, payments, shipments.
2. Normalise to around third normal form, but snapshot price and product name on order_items so later price changes do not alter past orders.
3. Use DECIMAL for money, an order status column driven by an explicit state machine, and indexes on foreign keys and common lookups (user_id on orders, SKU).
4. Prevent overselling with a conditional update (UPDATE inventory SET qty = qty - ? WHERE sku = ? AND qty >= ?) or SELECT ... FOR UPDATE inside a transaction.
5. Map it with Hibernate: lazy @OneToMany from order to items, a @Version column for optimistic locking, and fetch joins to avoid N+1 queries on order listings.

Follow-up

• How do you model products with different attributes, such as size for shoes and memory for phones?
• How would you handle a payment that succeeds after the stock ran out?
• Which queries get slow first as orders grow, and how do you fix them?

Explain the concept of microservices and its advantages.

Medium · System Design / Architecture

Approach

1. Define microservices as small, independently deployable services organised around business capabilities, each owning its own data.
2. Advantages: independent deployment and scaling, fault isolation, teams owning services end to end, freedom to choose technology per service.
3. Be balanced on costs: network latency and partial failure, no cross-service ACID transactions, harder debugging that needs distributed tracing and central logging, and more operational overhead.
4. Name the supporting pieces: an API gateway, service discovery, synchronous REST against asynchronous messaging, circuit breakers and timeouts.
5. Say when a well-structured monolith is the better start, and how the strangler-fig pattern moves out of one gradually.

Follow-up

• How do services communicate, and when would you choose a message queue over REST?
• How do you keep data consistent when an order spans several services?
• How would you split an existing Spring Boot monolith?

What considerations would you make for scalability in your design?

Medium · System Design / Architecture

Approach

1. Start from numbers: expected requests per second, read-to-write ratio, data growth, and latency targets; scalability decisions follow from them.
2. App tier: stateless services behind a load balancer for horizontal scaling, sessions kept in a shared store or tokens.
3. Data tier: indexes and query tuning first, then read replicas, caching hot reads, and partitioning or sharding when one primary cannot take the writes.
4. Move slow work off the request path with queues; size thread and connection pools (HikariCP is Spring Boot's default pool) to what the database can serve.
5. Verify with load tests and watch the first bottleneck, usually the database, before adding complexity.

Follow-up

• What breaks first when traffic grows tenfold in your design?
• How do you keep a cache consistent with the database?
• How would you choose a shard key, and what does it make expensive?

Describe how you would ensure data integrity in a distributed system.

Medium · System Design / Architecture

Approach

1. Inside one database, rely on ACID transactions plus constraints (foreign keys, unique, check) as the first defence.
2. Across services, avoid two-phase commit where possible and use a saga: a sequence of local transactions with compensating actions on failure.
3. Make delivery reliable with a transactional outbox (write the event in the same transaction as the data) and consumers that are idempotent, deduplicating by message or request ID, because delivery is at least once.
4. Handle concurrent writes with optimistic locking (a version column, @Version in Hibernate) or pessimistic locks where contention is high.
5. Add detection: reconciliation jobs comparing systems, checksums on transfers, and audit logs.

Follow-up

• When would you accept two-phase commit despite its costs?
• How does an idempotency key prevent a double charge on retry?
• What happens to your saga if a compensating action itself fails?

Describe how you would estimate the time needed to complete a software feature.

Medium · Problem-Solving / Case Studies

Approach

1. Break the feature into tasks: API, database changes and migration, business logic, UI if any, tests, code review, QA cycle, deployment.
2. Estimate each task as a range and identify the unknowns; run a short spike on the largest unknown before committing to a number.
3. Compare with similar past work or team velocity, and add explicit allowance for integration, QA fixes and review rather than a hidden fudge factor.
4. Communicate the estimate with its confidence level and its assumptions, and re-estimate when an assumption breaks.
5. If the team works in Agile, relate this to story points and sprint planning.

Follow-up

• What do you do when a manager wants a date before the unknowns are resolved?
• Tell me about an estimate you missed and why.
• How do you estimate work in an unfamiliar codebase?

What steps would you take to improve the performance of a slow application?

Medium · Problem-Solving / Case Studies

Approach

1. Define slow precisely: which pages or endpoints, which percentile (p95, p99), since when, and under what load.
2. Measure where time goes: application metrics or tracing, a profiler or Java Flight Recorder, slow-query logs, and EXPLAIN on suspicious MySQL queries.
3. Check the common Spring and Hibernate causes: N+1 queries (fix with fetch joins, entity graphs or batch fetching), missing indexes, connection-pool or thread-pool exhaustion, slow synchronous calls to other services, and long GC pauses.
4. Fix the biggest contributor first, then consider caching, pagination, async processing and payload size.
5. Re-measure after each change and keep a before-and-after number.

Follow-up

• How do you find an N+1 query problem in a Hibernate application?
• What would you do if the database is fine but the app is still slow?
• How do you stop the regression from coming back?

Analyze a case study and propose a solution.

Medium · Problem-Solving / Case Studies

Approach

1. Restate the case and ask clarifying questions about users, constraints, scale and what success means before suggesting anything.
2. Lay out two or three options with their trade-offs in cost, delivery effort, risk and maintenance.
3. Recommend one, say why it beats the others under the stated constraints, and name its main risk.
4. Describe rollout and measurement: a phased release, metrics that show it worked, and a fallback.
5. Practise with a few cases in the role's stack, such as replacing a slow report or splitting a module out of a monolith.

Follow-up

• What would change your recommendation?
• How would you explain the trade-off to a non-technical stakeholder?
• What would you build first with half the time?

How would you approach debugging a complex software issue?

Medium · Problem-Solving / Case Studies

Approach

1. Reproduce first: get exact inputs, environment and version; a bug you cannot reproduce needs more logging before more theories.
2. Collect evidence: stack traces, logs with request IDs, metrics around the time it started, and what changed (deploys, config, data).
3. Narrow systematically: bisect commits (git bisect), disable components, or add targeted logging; form one hypothesis at a time and test it.
4. Use Java tools by symptom: a thread dump (jstack) for hangs and deadlocks, a heap dump for memory growth, a profiler or Java Flight Recorder for CPU.
5. Fix the root cause, add a regression test that fails without the fix, and record what happened so others recognise it.

Follow-up

• How do you debug an issue that only happens in production and only occasionally?
• Walk through finding a memory leak in a Java service.
• How do you tell whether a deploy caused the bug or just coincided with it?

Suggested practice checklist

Each day covers one cluster of the reported questions, moving from Java concepts and hand-written coding to SQL, design and case questions, and ending on the managerial and HR stories.

Day 1 — Core Java and OOP concepts

• Write a comparison table of Java against C++ and Python on execution, memory, typing and inheritance.
• Write one small Java example for each OOP principle, including overloading against overriding and a Liskov violation.
• Write an interface with a default method, two implementations, and a Spring-style class that depends only on the interface.

Deliverable: A language comparison table, four OOP code examples and an interface example, each explainable aloud.

Day 2 — Java 8, newer JDK features and exceptions

• Rewrite three loops from your own code as stream pipelines using filter, map, flatMap and Collectors.groupingBy.
• List Java 8 features plus var, records, sealed classes and virtual threads, with one line of code each.
• Write a try-with-resources example, a custom exception that keeps its cause, and a @RestControllerAdvice handler mapping it to an HTTP status.

Deliverable: Three stream rewrites, a one-page feature sheet with code, and an exception-handling example.

Day 3 — Coding by hand

• In a plain editor, write the linked-list reversal iteratively and recursively, then compile and test on empty, one-node and two-node lists.
• Write the unique-characters check with a HashSet, a boolean array and a sort, stating each complexity.
• Write Fibonacci memoised, bottom-up and with two variables, then solve coin change with the same state-transition method, and take one O(n^2) solution down to O(n) with a HashMap.

Deliverable: Compiled, tested Java files for each problem with complexities noted at the top.

Day 4 — SQL and database design in MySQL

• Write the duplicates query three ways (GROUP BY/HAVING, ROW_NUMBER, self-join) and a delete that keeps the lowest id, then run them on a local MySQL table seeded with duplicates and NULLs.
• Sketch the e-commerce schema with keys, indexes and the conditional inventory update, then map orders and order items as Hibernate entities.
• Write the update path that detects a concurrent edit using a version column.

Deliverable: Working SQL scripts, an annotated schema diagram, and Hibernate entity classes with @Version.

Day 5 — System design

• Design the URL shortener end to end: APIs, base62 key generation, table, cache and redirect choice, with rough numbers.
• Write a one-page comparison of a monolith and microservices for an order system, including how a saga with an outbox keeps data consistent.
• List the scalability steps for that system in the order you would apply them and what triggers each.

Deliverable: A URL shortener diagram with numbers, a monolith versus microservices page, and an ordered scaling checklist.

Day 6 — Debugging, performance and case questions

• Write your debugging sequence and practise it on a real past bug, including which Java tool (thread dump, heap dump, profiler) fits which symptom.
• Reproduce an N+1 query in a small Spring Boot app with Hibernate logging on, then fix it with a fetch join and record the before-and-after query counts.
• Break a recent feature into tasks with estimate ranges, and work through one open case aloud using clarify, options, recommendation, rollout.

Deliverable: A debugging checklist, an N+1 before-and-after record, a feature estimate breakdown and a recorded case answer.

Day 7 — Screening, managerial and HR stories

• Write STAR outlines for the challenging project, prioritisation, collaboration and incomplete-information prompts, each with a measured result.
• Write short answers on motivation and handling criticism, each tied to a specific example.
• Decide your salary range, notice period and aspiration answer, and rehearse a resume walkthrough naming the Java, Spring Boot, Hibernate and SQL work in each project.

Deliverable: Six behavioral story outlines, a salary and aspirations note, and a resume walkthrough script.

Behavioural preparation

Candidates report that the managerial interview covers past experience, aspirations and salary expectations, and the HR interview covers experience and fit with the team. Prepare stories in which your own decisions are visible, with a result you can measure; the role's described work with product management and QA gives natural material for the collaboration prompts.

How do you handle exceptions in Java?

Medium · Technical / Domain Questions

Approach

1. Lay out the hierarchy: Throwable splits into Error (do not catch) and Exception; RuntimeException subclasses are unchecked, the rest are checked and must be caught or declared.
2. Describe the mechanics: try/catch/finally, multi-catch, and try-with-resources on AutoCloseable, which closes resources in reverse order and attaches close failures as suppressed exceptions.
3. State the practices: catch the most specific type, never swallow an exception silently, wrap with the cause preserved (new ServiceException(msg, e)), log once at the boundary, and define custom exceptions for domain errors.
4. Connect to Spring Boot: a @RestControllerAdvice with @ExceptionHandler methods mapping exceptions to HTTP statuses, and @Transactional rolling back on unchecked exceptions by default but not on checked ones unless rollbackFor is set.

Follow-up

• What happens if both the try block and finally block return a value or throw?
• When would you make a custom exception checked rather than unchecked?
• How do you keep a stack trace when translating a low-level exception to a domain one?

Describe a challenging project you worked on and how you overcame obstacles.

Medium · Behavioral / Leadership

Approach

1. Choose a project with a real technical obstacle you resolved yourself, such as a migration, a performance problem or an integration failure, ideally in Java or Spring.
2. Use STAR, keeping situation and task brief and spending most of the answer on what you did: the options you weighed and why you chose one.
3. Say 'I' for your own actions and credit others by name of role; a story told entirely as 'the team' hides your contribution.
4. End with a measurable result (latency, defect count, delivery date) and one thing you would do differently.

Follow-up

• What was the hardest technical decision in that project, and what was the alternative?
• Who disagreed with you, and how was it settled?
• What would have happened if you had not solved the obstacle?

How do you prioritize tasks when working on multiple deadlines?

Medium · Behavioral / Leadership

Approach

1. Give your method first: rank by impact and urgency, check dependencies (who is blocked on what), and size each item.
2. Then a real example with competing deadlines, showing what you did first, what you deferred, and that you told the affected people early.
3. Show negotiation: cutting scope, splitting a deliverable, or asking a manager to choose between two priorities rather than silently missing one.
4. Avoid the answer that you simply worked longer hours; it shows no prioritisation.

Follow-up

• Tell me about a time a priority call you made turned out wrong.
• How do you handle two stakeholders who both say their work is most urgent?
• How do you track commitments so nothing is dropped?

Give an example of how you've worked collaboratively with others.

Medium · Behavioral / Leadership

Approach

1. The role is described as working with product management and QA, so a story with one of those groups fits well.
2. Show a specific interaction: aligning requirements with a product manager, or working with QA to reproduce and fix a defect before a release.
3. Include friction and how you resolved it, such as a disagreement over scope or test coverage, settled with data or a compromise.
4. State the outcome and your personal contribution to it.

Follow-up

• What did you do when a teammate was not delivering their part?
• How do you handle a QA defect report you believe is not a bug?
• What would that colleague say about working with you?

What motivates you to succeed in your work?

Medium · Behavioral / Leadership

Approach

1. Name one or two concrete motivators and prove each with an example, such as shipping a feature real users rely on, or tracking down a hard production bug.
2. Tie motivation to the work of this role: backend Java development across the lifecycle, from design to maintenance.
3. Keep it honest and specific; generic lines about loving challenges sound rehearsed.
4. Link it forward to your aspirations, which candidates report the managerial interview covers.

Follow-up

• Describe a time your motivation dropped and what you did about it.
• What kind of work do you find least motivating?
• Where do you want to be technically in a few years?

How do you handle criticism?

Medium · Behavioral / Leadership

Approach

1. Use a real example, ideally code-review feedback or a post-incident review, where the criticism had substance.
2. Show the sequence: listen without defending, ask clarifying questions, decide whether you agree, then change something concrete.
3. Include what changed afterwards, such as a testing habit or a design practice you adopted.
4. Show you can disagree respectfully when feedback is wrong, backing your view with evidence.

Follow-up

• Tell me about feedback you disagreed with. What happened?
• How do you give critical feedback in a code review?
• What is the most useful criticism you have received?

Discuss a time when you had to make a difficult decision based on incomplete information.

Medium · Problem-Solving / Case Studies

Approach

1. Pick a decision with real stakes where waiting for full information was not an option, such as a production incident or a deadline-bound design choice.
2. Say what you knew, what you did not, and how you bounded the risk: a reversible choice, a feature flag, a rollback plan, or a quick spike to gather the most important missing fact.
3. Explain who you consulted and how you communicated the uncertainty.
4. Give the outcome honestly, including anything that went wrong, and what you would change.

Follow-up

• What information would have changed your decision?
• How did you know when you had enough information to act?
• Tell me about a decision like this that turned out badly.