Skill reading | HackIndia

1. Java project worth showing

5 min

What counts

A Java project worth showing is not a large app. It is a finished app that another person can run without asking you questions.

For this track, you will build a command-line recruiter helper. It reads candidate data, applies simple logic, prints useful results, and handles bad input cleanly.

Key point

Remember this

Your repo should prove one thing clearly: you can turn a small problem into working Java code that someone else can build and run.

Internship reviewers do not need 20 features. They need evidence of structure, correctness, and care.

Your to-do

Choose the promise

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Pick one user: a recruiter, placement cell volunteer, or student coordinator.
Pick one job: shortlist candidates, search resumes, rank applicants, or filter by skills.
Pick one input: CSV or JSON sample data kept inside the repo.
Pick one output: a clean table, a shortlist file, or a summary in the terminal.
Avoid login, web UI, databases, and dashboards for this track.

0 of 5 done

Example

Good project scope

Here is a small promise you can actually ship.

It is specific enough to guide your classes later, but not so big that it blocks you.

Project name: recruit-shortlister

What it does:
Reads candidate records from sample data.
Filters candidates by role, minimum CGPA, and required skills.
Prints a ranked shortlist in the terminal.
Shows clear error messages for missing or invalid data.

Example command idea:
java -jar recruit-shortlister.jar data/candidates.csv backend 7.5 java,sql

2. Types and collections

4 min

Key point

One idea

Types protect meaning. Collections protect structure. In a recruiter CLI, use simple types for one value and collections for many values.

Use the right type

A job title is a String. Years of experience is an int. A salary range can start as two int values in rupees per month. A yes/no field, like remote allowed, is a boolean.

Avoid storing everything as String just because input comes from the terminal or a CSV file. Convert early, then the rest of your code becomes easier to trust.

Choose collections

Use a List when order matters or duplicates are allowed. Job applications in the order they were loaded can be a List.

Use a Set when duplicates should not exist. A candidate’s skills are a Set because Java should appear once, not five times.

Use a Map when you need fast lookup by a key. Recruiter name to open job count can be a Map.

Example

3. Classes and interfaces

5 min

Key point

One idea

A class should represent one real thing in your app. An interface should represent one action your app can swap or improve later.

For a recruiter CLI, Candidate and Job are classes. MatchScorer is an interface because matching can change from simple keywords to a better scoring rule.

Why this matters

A project repo looks stronger when your code is not one long Main.java file. Recruiter apps have clear nouns: candidate, job, skill, application, score.

When each idea has its own class, another builder can open your repo and understand it fast. This also helps later lessons when you add files, JSON, streams, and a build tool.

Your to-do

Choose your classes

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

5. Streams and lambdas

4 min

Key point

One idea

A lambda is a short function value. A stream is a clean way to process a collection step by step without writing manual loops for every task.

Where this fits

Your recruiter CLI will have candidate data in lists. You may need to show shortlisted candidates, count skills, sort by score, or print names in a clean format.

You can do all of that with normal for loops. Streams are useful when the job is a pipeline: filter, transform, sort, collect.

Example

Candidate example

Assume your Candidate class has name, city, skills, and score getters. This code finds Java candidates in Bengaluru or remote-ready candidates, sorts by score, and prints a shortlist.

4. Generics and exceptions

4 min

Key point

One idea

Generics stop wrong data from entering your collections. Exceptions make failure visible and controlled.

In your recruiter CLI, use both together: typed data in, clear error out.

Why generics matter

A recruiter app will hold candidates, jobs, skills, and match scores. If you use raw List or Map, Java cannot protect you from mixing them up.

Prefer List, Map, and Optional style types. The compiler then catches mistakes before your friend tries to run the repo.

Example

Typed collections

This is better than putting everything into one ArrayList. The method says exactly what it accepts and returns.

import java.util.ArrayList;
import java.util.List;

public class CandidateStore {
    private final List<Candidate> candidates = new ArrayList<>();

    public void add(Candidate candidate) {
        candidates.add(candidate);
    }

    public List<Candidate> findBySkill(String skill) {
        List<Candidate> result = new ArrayList<>();

        for (Candidate candidate : candidates) {
            if (candidate.skills().contains(skill)) {
                result.add(candidate);
            }
        }

        return result;
    }
}

Use custom exceptions

A bad email, missing name, or invalid experience should not crash your app with a random NullPointerException. Create a small exception that explains the problem.

Use checked exceptions when the caller should deal with the error. Use unchecked exceptions for programmer mistakes. For input data from users or files, a checked exception is often clearer.

Example

Validate candidate data

This example rejects bad data early. The calling code must decide what to show to the user.

public class InvalidCandidateException extends Exception {
    public InvalidCandidateException(String message) {
        super(message);
    }
}

public record Candidate(String name, String email, int experienceYears, List<String> skills) {
    public Candidate {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Candidate name is required");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Candidate email is invalid");
        }
        if (experienceYears < 0) {
            throw new IllegalArgumentException("Experience cannot be negative");
        }
    }
}

Common mistake

Do not swallow errors

Beginners often write catch blocks that print nothing or only say "error". That makes debugging painful during a hackathon demo.

Show a short user-friendly message. Keep the original message useful for fixing the issue.

try {
    Candidate candidate = parser.parseCandidate(inputLine);
    store.add(candidate);
} catch (InvalidCandidateException e) {
    System.out.println("Skipped candidate: " + e.getMessage());
}

Tip

Ask AI carefully

You can ask ChatGPT or Gemini to review your exception design. Paste only the relevant class, not private data.

Check that the AI does not suggest raw List, broad catch (Exception e), or System.exit inside business classes. Your app should handle errors near the CLI layer.

Prompt:
Review this Java CLI class. Suggest better generics and exception handling.
Do not rewrite the whole app. Point out raw types, broad catches, and unclear error messages.

Your to-do

Do this now

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Replace any raw List, ArrayList, Map, or HashMap with typed generics.
Add validation for Candidate or Job fields that can be wrong.
Create one clear exception type for invalid input data.
Handle that exception in your CLI command flow with a useful message.
Commit the changes with a message like: add generics and input validation.

0 of 5 done

6. Files and JSON handling

4 min

Key point

One rule

Your CLI should treat files as input, not as your program’s memory. Read data at the edge, convert it into Java objects, then let the rest of your code work with those objects.

Why JSON here

For this recruiter project, JSON is a good sample data format. It is readable, common in APIs, and easy for another builder to edit before running your app.

Use it for things like candidates, jobs, skills, cities, expected salary, or application status. Keep the file small enough to understand in one screen.

Example

Sample data file

Place sample files in a clear folder like data/. Do not hide them inside random package folders.

Example: data/candidates.json

[
  {
    "id": 1,
    "name": "Asha Nair",
    "city": "Kochi",
    "skills": ["Java", "SQL", "Git"],
    "expectedSalaryLpa": 6.0
  },
  {
    "id": 2,
    "name": "Rohit Sharma",
    "city": "Pune",
    "skills": ["Java", "Spring", "PostgreSQL"],
    "expectedSalaryLpa": 8.5
  }
]

Reading files safely

In Java, use Path and Files from java.nio.file for normal file work. They are cleaner than old File code for most CLI apps.

Start with plain file reading. Then parse the JSON using a library such as Jackson or Gson once your build lesson adds dependencies.

Example

Read a JSON file

This method reads the full file into a String. Your JSON parser can use that string later.

It also gives a clear error if the file is missing, which is better than a long stack trace during a demo.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class JsonFileReader {
    public static String readJson(String filePath) {
        Path path = Path.of(filePath);

        if (!Files.exists(path)) {
            throw new IllegalArgumentException("File not found: " + filePath);
        }

        try {
            return Files.readString(path);
        } catch (IOException e) {
            throw new RuntimeException("Could not read file: " + filePath, e);
        }
    }
}

// Usage:
// String json = JsonFileReader.readJson("data/candidates.json");

Common mistake

Avoid hard-coded data

A common beginner mistake is creating all candidates inside main(). That makes your project look like a coding exercise, not a usable CLI tool.

Keep two or three sample records in JSON. Let the user pass the file path later, or keep a sensible default like data/candidates.json.

Tip

Check AI output

If you ask an AI tool to create sample JSON, check three things before committing it: valid JSON syntax, realistic field names, and data that matches your Java class names and types.

For example, do not let one record use expectedSalary and another use expectedSalaryLpa unless your parser is built for that.

Your to-do

Do this now

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Create a data folder in your project root.
Add candidates.json with 2 to 5 realistic candidate records.
Write a small JsonFileReader class using Path and Files.readString.
Run your app once with the correct file path and once with a wrong path.
Make the error message clear enough for another builder to fix it.

0 of 5 done

7. Maven or Gradle basics

4 min

Key point

One build command

A good repo is not just source code. It has a build tool so another builder can clone it and run one clear command.

Use Maven or Gradle. For this track, Maven is the simpler default because many Java examples and college labs already use it.

What Maven does

Maven reads a file named pom.xml. That file tells Maven your Java version, dependencies, and how to compile the app.

You do not need to install every library by hand. If your project uses a JSON library, Maven downloads it from its central repository during the build.

Example

Small Maven file

Put this pom.xml in the root of your project. Update the groupId, artifactId, and mainClass for your app.

This example uses Java 17 and creates a runnable CLI jar with dependencies included.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>in.hackindia</groupId>
    <artifactId>recruiter-cli</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.17.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.6.0</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>in.hackindia.recruiter.Main</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Your to-do

Standard layout

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Create src/main/java for Java files.
Place your main class under a package, like in.hackindia.recruiter.
Keep sample JSON or CSV data in a data folder at the repo root.
Keep pom.xml at the repo root, not inside src.
Commit generated target files only if you have a reason. Usually add target/ to .gitignore.

0 of 5 done

Example

Build and run

From the project root, run these commands. This is what another builder should be able to do after cloning your repo.

mvn clean package
java -jar target/recruiter-cli-1.0.0.jar data/candidates.json

Common mistake

Common build mistake

Do not write instructions that only work in your IDE. HackIndia reviewers and other builders may use VS Code, IntelliJ, Eclipse, or only the terminal.

Your project should build from a fresh clone. If it needs a manual library download or a local absolute path like C:\Users\name\file.json, fix that.

Tip

Use AI carefully

You can ask ChatGPT, Gemini, or Claude to draft a pom.xml. Paste your package name, main class, Java version, and dependencies.

Check the result. Make sure the mainClass is real, the dependency versions exist, and the commands work on your machine before you commit.

Your to-do

Do this now

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Choose Maven unless you already know Gradle well.
Add pom.xml to the root of your recruiter CLI repo.
Build with mvn clean package and fix compile errors.
Run the jar from the terminal using your sample data file.
Copy the exact build and run commands into your README.

0 of 5 done

8. Submit your public repo

4 min

Key point

Repo is the proof

Your project is not finished when it works on your laptop. It is finished when another builder can clone it, build it, run it, and understand what it does.

For HackIndia submission, your public repo must include the build file, source code, sample data, and clear run instructions.

What reviewers check

A recruiter-style Java CLI project should look boring in a good way. The folder names should be normal. The commands should be copy-paste friendly.

Do not depend on hidden files, local absolute paths, or your IDE. Someone should be able to run it from Terminal, PowerShell, or a college lab machine with Java and Maven or Gradle installed.

Your to-do

Final repo checklist

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Keep source code under src/main/java.
Keep sample input under data or src/main/resources.
Commit your Maven pom.xml or Gradle build.gradle.
Add a README with setup, build, run, and sample output.
Make the repository public before you submit.

0 of 5 done

Example

README that works

Use simple instructions. Mention the Java version you tested with. Show the exact command you expect someone to run.

This example assumes a Maven app that reads a JSON file from data/candidates.json.

# Recruiter CLI

A Java command-line app that reads candidate data and prints a shortlist.

## Requirements

- Java 17
- Maven 3.9 or later

## Build

mvn clean package

## Run

mvn exec:java -Dexec.mainClass="com.hackindia.recruiter.Main" -Dexec.args="data/candidates.json"

## Sample data

The sample file is included at:

data/candidates.json

## Expected output

Shortlisted candidates:
1. Asha Sharma - Java, SQL
2. Imran Khan - Java, Git

## Project structure

src/main/java - Java source code
data - sample input files
pom.xml - Maven build file

Common mistake

Avoid local paths

Do not write paths like C:\Users\Rahul\Desktop\candidates.json or /home/me/project/data.json in your code or README. They only work on your machine.

Accept the file path as a command-line argument, or use a relative path like data/candidates.json in examples.

Tip

Test like a stranger

Before submitting, make a fresh clone in a different folder. Run only the README commands. If anything is missing, fix the repo and test again.

You can ask an AI tool to review your README, but check that it does not invent commands, plugins, folders, or features your project does not have.

git clone https://github.com/YOUR-USERNAME/recruiter-cli.git test-run
cd test-run
mvn clean package

Your to-do

Submission flow

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Push your final code to GitHub or another public Git host.
Open the repo in a private browser window to confirm it is public.
Check that sample data is committed and not ignored by .gitignore.
Copy the public repo URL into your HackIndia project submission.
Add a short project description that matches what the CLI actually does.

0 of 5 done

Your to-do

Do this now

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Create or update your README with build and run commands.
Add one sample data file that your CLI can read.
Clone your repo into a new folder and run it from the README only.
Fix any missing files, wrong commands, or local paths.
Submit the public repo link on HackIndia when the clean run works.

0 of 5 done

Java

1. Java project worth showing

What counts

Remember this

Choose the promise

Good project scope

2. Types and collections

One idea

Use the right type

Choose collections

3. Classes and interfaces

One idea

Why this matters

Choose your classes

5. Streams and lambdas

One idea

Where this fits

Candidate example

Do not build vague

Use AI carefully

README first draft

Do this now

Recruiter data example

Common mistake

Let AI help safely

Do this now

Candidate class

Job class

Interface for scoring

Common mistake

Do this now

4. Generics and exceptions

One idea

Why generics matter

Typed collections

Use custom exceptions

Validate candidate data

Do not swallow errors

Ask AI carefully

Do this now

Read the pipeline

Use streams safely

Do not over-chain

Use AI carefully

Do this now

6. Files and JSON handling

One rule

Why JSON here

Sample data file

Reading files safely

Read a JSON file

Avoid hard-coded data

Check AI output

Do this now

7. Maven or Gradle basics

One build command

What Maven does

Small Maven file

Standard layout

Build and run

Common build mistake

Use AI carefully

Do this now

8. Submit your public repo

Repo is the proof

What reviewers check

Final repo checklist

README that works

Avoid local paths

Test like a stranger

Submission flow

Do this now