Software

Determine the time and space complexity of a short Java solution.

Solve an array or string problem with a single-pass traversal.

Use a HashMap or HashSet to replace repeated searches in a Java solution.

Recognize and apply the two-pointer pattern to a sorted sequence problem.

Recognize and apply a sliding-window pattern to a contiguous-range problem.

Use a stack to solve a balanced-delimiter matching problem in Java.

Implement insertion, deletion, and traversal operations on a singly linked list.

Apply binary search while maintaining correct low and high boundary invariants.

Trace an HTTP request through the controller, service, and repository layers of a Spring Boot application.

Choose appropriate HTTP methods and status codes for common CRUD operations.

Implement a REST controller whose routes follow resource-oriented URL conventions.

Place business rules in a Spring service rather than in a controller or repository.

Use request and response DTOs to isolate an API contract from persistence entities.

Validate incoming request data with Jakarta Bean Validation annotations.

Return consistent API error responses with centralized exception handling.

Document and manually verify REST endpoints with OpenAPI and Postman.

Design normalized PostgreSQL tables from stated requirements for users, job applications, and application status history.

Write SQL queries that use filtering, sorting, aggregation, and joins.

Map a Java entity to a PostgreSQL table with JPA annotations.

Model one-to-many and many-to-one relationships with appropriate JPA mappings.

Implement standard and derived queries with a Spring Data JPA repository.

Define a transaction boundary for a multi-step database operation.

Add status filtering, pagination, and sorting to a Spring Data-backed job-application endpoint.

Manage repeatable database schema changes with Flyway migrations.

Structure a web page with semantic HTML elements and a logical heading hierarchy.

Build an accessible HTML form with associated labels and appropriate input types.

Predict how the CSS cascade, specificity, inheritance, and box model affect an element.

Arrange a responsive navigation or toolbar with Flexbox.

Create a two-dimensional dashboard layout with CSS Grid.

Adapt a page to mobile and desktop widths with media queries.

Inspect and correct layout and style problems with browser developer tools.

Reproduce a responsive application screen from a simple visual specification.

Predict the results of operations involving JavaScript primitives, objects, null, undefined, strict equality, and truthiness.

Write functions that use const, let, parameters, return values, and conditional control flow with predictable scope.

Transform arrays of objects with map, filter, find, and reduce.

Use destructuring, spread syntax, and optional chaining when working with application data.

Handle browser events and update selected DOM elements.

Read and validate values submitted through an HTML form.

Organize browser code with ES modules and named exports.

Fetch JSON asynchronously and handle both HTTP and network failures.

Create and run a React application with Vite.

Build a reusable React function component from a static interface section.

Pass data and callbacks between React components with props.

Manage local component state with the useState hook.

Explain how component identity and state updates determine when React re-renders.

Render collections and conditional interface states with stable keys.

Implement a controlled React form and process its submission.

Use the useEffect hook for a synchronization task while avoiding an unnecessary effect loop.

Annotate function parameters, return values, arrays, and object shapes with TypeScript.

Use a union type to represent a finite set of interface or domain states.

Type React component props, state, and browser events with TypeScript.

Configure client-side pages and navigation with React Router.

Create a typed API client that calls a Spring Boot endpoint.

Represent loading, success, empty, and error states in a data-driven component.

Extract reusable data-fetching behavior into a custom React hook.

Share authenticated-user state through React Context without unnecessary prop passing.

Compare session-based and token-based authentication and select an approach for a stated deployment scenario.

Implement user registration that stores passwords with a Spring Security-supported password encoder.

Implement a login endpoint that authenticates credentials and issues a signed access token.

Configure a Spring Security filter chain that validates bearer tokens and distinguishes public from protected routes.

Enforce ownership or role checks on a protected backend operation.

Configure cross-origin access for a known frontend origin without allowing every origin.

Attach authentication credentials to frontend API requests and handle expired access.

Protect a React route and redirect unauthenticated users to a sign-in page.

Write a JUnit test for a Java class with normal and edge-case assertions.

Isolate a Spring service test with Mockito mocks and interaction verification.

Test a Spring MVC endpoint with MockMvc.

Verify a JPA mapping or repository query with a focused data-layer test.

Test visible React component behavior with React Testing Library.

Mock an API boundary while testing a React loading or error state.

Perform a focused review of correctness, readability, security, and test coverage, then correct one identified issue.

Configure a GitHub Actions workflow to run backend and frontend build and test checks on pull requests.

Convert the job-application tracker MVP into prioritized user stories with testable acceptance criteria.

Connect a typed React create-application form to the authenticated Spring Boot endpoint and verify that the submitted record is persisted.

Build a React application list that consumes the filtered, sorted, and paginated backend endpoint.

Implement a protected backend operation that changes an application's status and records its status history.

Connect a React status control to the protected status-update endpoint and display the resulting state.

Package the backend and its runtime configuration with Docker.

Deploy the managed PostgreSQL database and Spring Boot backend, then verify API health in the deployed environment.

Deploy the React client with production API configuration and complete an end-to-end smoke test of the deployed application.

Trace a recursive Java function and identify its base case and progress step.

Implement depth-first traversal of a binary tree in Java.

Implement breadth-first traversal of a binary tree with a queue.

Explain the end-to-end flow of a request through the React, Spring Boot, and PostgreSQL capstone.

Create a capstone README containing setup instructions, architecture notes, API information, screenshots, and deployed links.

Present a concise portfolio walkthrough that explains technical choices, trade-offs, testing, and deployment.

Tailor achievement-focused résumé bullets and keywords to a Hyderabad junior Java full-stack job description.

Deliver a structured behavioral interview answer using the STAR format.