PSG College of Technology Students: Preparing for Java and Enterprise Software Internship Interviews

You prepare for a Java internship interview by working through four layers in order: core Java, Spring concepts, SQL and REST design. Then you tie them together in a project you can explain end to end. Allow about five weeks of steady practice, and score yourself against the table below so you know which layer is weakest.

This guide is an independent resource for students of PSG College of Technology. It is not issued by, or connected to, the institution. It makes no claims about hiring outcomes. It sets out what Java and enterprise-software interviewers commonly probe, how to practise it, and how to check your own college’s process.

How Java internship interviews are usually structured

Formats differ by company, but most Java and enterprise-software internship screens combine some of these elements:

• An online screen or written test: aptitude, multiple-choice questions on Java and SQL, and one or two coding problems.
• A technical round: questions on language fundamentals, object-oriented design, collections, exceptions and concurrency basics, often with a small coding task.
• A framework and data round: Spring or Spring Boot ideas, SQL queries, and how you would design a small API.
• A project discussion: you walk through something you built and defend your decisions.
• An HR or manager conversation: motivation, teamwork, how you learn.

Treat this as a typical pattern, not a rule. A given company may skip stages or merge them. The plan below covers the technical content that recurs across formats.

The five-week staged plan

Stage 1: Core Java and object-oriented fundamentals

Interviewers use core Java to see whether you understand what the language does, not just how to type it. Prepare to explain each topic in two or three sentences and then give a small example.

Topics to be able to explain

• Classes, objects, interfaces and abstract classes: when you would choose an interface over an abstract class, and what default methods in interfaces changed.
• The four OOP pillars: encapsulation, inheritance, polymorphism, abstraction, each tied to a concrete example from code you wrote.
• String handling: immutability, the string pool, String versus StringBuilder.
• equals() and hashCode(): the contract between them and why breaking it corrupts a HashMap or HashSet.
• Collections: ArrayList versus LinkedList, HashMap versus TreeMap versus LinkedHashMap, and how a hash map handles collisions at a high level.
• Exceptions: checked versus unchecked, try-with-resources, and why you should not swallow exceptions silently.
• Generics, lambdas and streams: a basic map, filter, collect pipeline and Optional.
• Memory and the JVM: stack versus heap, garbage collection at a conceptual level, and what final, static and volatile do.
• Concurrency basics: threads versus Runnable, synchronized, ExecutorService, and what a race condition is.

Practice prompts for Stage 1

1. Explain what happens if two objects are equal by equals() but return different hash codes, and then use them as keys in a HashMap.
2. Why is String immutable, and what are the benefits for security and caching?
3. Write a method that finds the first non-repeating character in a string, then state its time and space complexity.
4. Given a list of employee objects, group them by department and compute the average salary per department using streams.
5. Describe a situation in which you would pick ArrayList and one in which you would not.
6. What is the difference between throw, throws and finally?
7. Show how a deadlock can occur between two threads and how you would avoid it.

Stage 2: Spring and Spring Boot concepts

For an internship, nobody expects deep framework internals. They expect you to understand the ideas that make Spring applications work and to have built at least one small service yourself.

Concepts to be able to explain

• Inversion of control and dependency injection: the framework creates and wires objects instead of your code calling new. Know why constructor injection is generally preferred over field injection (clearer dependencies, easier testing).
• Beans and scopes: what a bean is, how @Component, @Service and @Repository differ in intent, and what singleton scope means.
• Spring Boot’s role: auto-configuration, starters, embedded server, and externalised configuration through application.properties or YAML.
• Layered structure: controller, service and repository, and what belongs in each.
• Spring Data JPA: entities, repositories, derived query methods, and the idea of mapping objects to tables.
• Validation and error handling: bean validation annotations and a centralised exception handler.
• Transactions: what @Transactional is for and what rollback means.
• Testing: the difference between a unit test and an integration test, and why you might mock a repository.

Practice prompts for Stage 2

1. Explain dependency injection to someone who has only written plain Java programs.
2. What is the difference between @Controller and @RestController?
3. Your service method updates two tables and the second update fails. What should happen, and how do you make it so?
4. What is the N+1 query problem in JPA, and how would you notice it?
5. How would you keep a database password out of your source code?

Stage 3: SQL and data access

SQL questions are common because nearly every enterprise application sits on a relational database. Practise writing queries by hand, without an autocomplete tool, on a schema you design yourself.

Skills checklist

• Filtering, sorting and limiting rows.
• Inner, left and self joins, and what each returns when rows have no match.
• GROUP BY with HAVING, and the difference between WHERE and HAVING.
• Subqueries and common table expressions.
• Primary keys, foreign keys, unique constraints and indexes, and the trade-off an index brings to writes.
• Normalisation up to third normal form, explained with a small example.
• Transactions and the meaning of atomicity, consistency, isolation and durability.
• Reading a basic query plan, at least to say whether an index is being used.

Practice prompts for Stage 3

Use a schema with students, courses and enrolments tables, or a similar one of your own.

1. List students who have not enrolled in any course.
2. Find the course with the second-highest number of enrolments.
3. Return departments whose average marks exceed the overall average.
4. Find duplicate email addresses in a table.
5. Explain why a query filtering on a column slows down as the table grows, and what you would add.
6. When would you choose a left join over an inner join?

Stage 4: REST API design

Interviewers use REST questions to see whether you can think about a system from the outside, as a client would. A strong answer names resources, picks correct methods and status codes, and mentions failure cases.

Design principles to know

• Resources as nouns: /students/42/enrolments rather than /getEnrolments.
• HTTP methods: GET reads, POST creates, PUT replaces, PATCH changes part of a resource, DELETE removes.
• Idempotency: why GET, PUT and DELETE are expected to be safe to repeat and POST is not.
• Status codes: 200, 201, 204, 400, 401, 403, 404, 409 and 500, and when each applies.
• Pagination, filtering and sorting for list endpoints.
• Versioning and backward compatibility at an introductory level.
• Authentication versus authorisation, and a basic idea of token-based access.
• Statelessness: each request carries what the server needs.

Practice prompts for Stage 4

1. Design the endpoints for a library system with books, members and loans. State the method, path and status code for each.
2. A client sends a POST to create an order twice because of a network retry. How do you prevent duplicate orders?
3. When should an API return 400 and when 422 or 409?
4. How would you paginate a list of 100,000 records, and what are the drawbacks of offset-based pagination?

Stage 5: The project walkthrough

The project discussion is where many internship interviews are won or lost, because it is the one part you control completely. Prepare a five-minute script with a fixed order: problem, users, architecture, your own contribution, one hard problem, and what you would improve.

Project walkthrough worksheet

Illustrative worked example

The example below is illustrative only. It shows how a student might structure an answer for a hypothetical project, a campus lab-booking service. The code is a sketch for explanation and has not been compiled or run.

Opening (about 30 seconds): “I built a REST service that lets students book lab slots and lets staff approve them. The problem was that bookings were tracked on paper and double-booked. I used Spring Boot with a relational database, and I wrote the booking and conflict-checking logic myself.”

Architecture (about 60 seconds): The controller receives a booking request and validates the input. The service checks for overlapping slots and applies the rules. The repository saves the entity. The database has a unique constraint on lab and slot so that two simultaneous requests cannot both succeed.

The hard problem (about 90 seconds): Two students could book the same slot at the same moment. A check-then-insert in the service was not enough, because both requests passed the check. The fix was to rely on the database constraint, catch the violation, and return a 409 Conflict. A sketch of the idea:

@Transactional
public Booking book(BookingRequest req) {
    Booking b = new Booking(req.labId(), req.slot(), req.studentId());
    try {
        return bookingRepository.saveAndFlush(b);
    } catch (DataIntegrityViolationException e) {
        throw new SlotAlreadyBookedException(req.labId(), req.slot());
    }
}

A centralised exception handler then maps SlotAlreadyBookedException to a 409 response with a clear message.

Likely follow-ups and how to answer:

• Why flush inside the method? So the constraint violation surfaces while you are still in the try block, not at commit time.
• What would you improve? Add integration tests for the concurrent case and pagination on the list endpoint.
• What did you not test? Say so plainly. Naming a gap honestly reads better than claiming everything was covered.

Self-scoring scorecard

Rate yourself from 1 to 4 on each row at the start of week one and again at the end of week five. Be strict: a 4 means you can explain it aloud, with an example, without notes.

Any row below 3 after week three gets extra time before you move on. Two rows at 4 do not offset a row at 1.

A weekly routine that fits a semester

• Weekdays, about 90 minutes: one concept review, one coding or query problem, and written notes in your own words.
• One weekend block of three hours: build or extend your project, then explain the change aloud as if to an interviewer.
• Every second week: a peer mock interview of 30 minutes, with the interviewer using the prompts above in random order.

Keep a mistakes log: each wrong or hesitant answer, the correct answer, and the date you will retry it. Reviewing this log is usually worth more than solving more new problems.

Getting project evidence if yours is thin

If you do not yet have a project to walk through, structured practical work helps. The free two-week online internship at CareerSwami runs for 14 days across 26 tracks, and it provides a free offer letter and a free completion certificate after successful completion. Whatever you build, in a programme or on your own, apply the walkthrough worksheet to it and be ready to say exactly which parts you wrote.

PSG Tech and Java internship interviews: using the 2023 scheme as your evidence base

For a Java or enterprise software interview, the strongest material is usually academic work you can explain line by line. A document linked from the college site, an Academic Council meeting document on the NAAC pages, states that the council considered regulations, courses of study, scheme of assessment and syllabi for BE/BTech regular programmes under the 2023 regulations (Choice Based Credit System). Which regulation applies to you depends on your admission year, so identify your own batch’s version before assuming anything.

The same document is an excerpt, and it mentions industrial training, mini project/internship, inplant training and project work as components of the 2023 scheme. It also says courses such as laboratory work and industrial training are assessed out of 100 marks, split into 40 for continuous assessment and 60 for final evaluation. The excerpt is fragmentary, so credits, semester and duration are not confirmed by it. Check the current curriculum document for the details.

In practice, this suggests three things for Java preparation:

• Keep evidence that supports assessment. If industrial training or a mini project is evaluated, a written record of what you built, which parts were yours and what you learned helps both the evaluation and the Stage 5 project walkthrough.
• Prepare to discuss lab and mini-project work in interview language. Be ready to explain class design, SQL queries and any REST endpoints in it, tying it to Stages 1, 3 and 4.
• Do not assume an interview-prep internship fits the scheme automatically. Whether a self-arranged or online internship can be recorded under these components is a question for your department, not something the excerpt settles.

Rules on documents, approval and timing are not covered by the excerpt, so rely on current written instructions from your department rather than seniors’ memories of earlier batches.

Checks to make before you commit to a Java internship

• Find the curriculum and regulations document for your admission year and read the industrial training, inplant training and mini project/internship entries.
• Ask your class advisor or internship coordinator whether the internship you plan counts toward any of those components, and in which semester.
• Ask what evidence the evaluation expects, such as a report, supervisor letter, certificate or presentation, and the deadlines.
• Ask whether an online internship is accepted in the same way as an on-site one.
• Confirm with the training or placement office any registration or eligibility conditions for company drives and practice sessions.
• Keep every approval or reply in writing, with the date.

Interview-day habits that help

• Think aloud. State your approach before writing code, and name the complexity afterwards.
• Clarify the problem. Ask about input size, null values and duplicates before you start.
• Say when you do not know. Then reason from what you do know. Guessing confidently is penalised more than honest reasoning.
• Test your own code. Walk through one normal case and one edge case on the spot.
• Prepare questions to ask. For example, what a first-month task for an intern looks like, and how code review works on the team.

Common mistakes in Java and Spring internship interviews

• Memorising definitions without examples, which falls apart at the first follow-up question.
• Listing Spring, Hibernate, Docker and Kubernetes on a résumé when you can only discuss one of them.
• Describing team projects as if you wrote every module.
• Skipping SQL because it feels less exciting than frameworks.
• Practising only on screen, never speaking your answers aloud.

Frequently Asked Questions

How much Spring Boot do I need for a Java internship interview?

Enough to build and explain a small layered CRUD service: controller, service, repository, an entity, validation and error handling. Be able to explain dependency injection and what auto-configuration does. Deep internals are rarely expected at intern level.

Should I learn Spring before I am strong in core Java?

No. Spring relies on interfaces, annotations, generics and collections, so weak fundamentals make the framework confusing. Spend the first two weeks on core Java, then move on.

Which SQL topics are asked most often?

Joins, GROUP BY with HAVING, subqueries, finding duplicates, and the nth-highest value type of question are frequent. Indexes and transactions come up as conceptual questions. Write these by hand until you rarely need to look anything up.

What if my project is a tutorial clone?

Extend it in a way you can explain: add a feature, change the data model, or add tests. In the interview, say clearly what you added and why. Presenting borrowed code as your own tends to collapse under follow-up questions.

Do I need to know microservices?

For most internship roles, a clear understanding of a well-structured monolith matters more. Know what microservices are and the trade-offs against a monolith, but do not claim hands-on experience you lack.

How many coding problems should I solve?

Quality matters more than a target number. Solve problems across arrays, strings, hash maps, sorting and basic recursion, and review each solution until you can explain its complexity. Twenty to forty well-understood problems beat a hundred half-remembered ones.

Does a certificate from an online internship help in interviews?

A certificate alone proves little. What helps is the work behind it: be ready to describe what you built, which decisions you made and what you learned. Any certificate is a supporting document, not a substitute for explanation.

How do I find out whether my college accepts an external online internship?

Ask your department coordinator in writing, quoting the exact programme, its duration and the documents it issues. Request the answer by email or on the department’s letterhead so you have a record.

Related Java & Enterprise Software guides

• Thiagarajar College of Engineering Students: Comparing Java Enterprise Internship Roles and Paths
• Java Enterprise Internship Portfolio Evidence for Kumaraguru College of Technology Students
• Vishwakarma Institute of Technology, Pune Students: Writing a Java Enterprise Internship Report
• All Java & Enterprise Software internship guides