Resumator — Project Planning & Setup

Part 1 — Building Something Real

Welcome to the most exciting part of the Coders Farm curriculum. Over the next six lessons, you are going to build a real application that you will actually use in your job search. Not a toy project. Not a tutorial exercise. A genuine tool that searches for real job listings, lets you browse results, save your favorites, and manage your job search — all powered by a Spring Boot backend and a MySQL database.

This application is called Resumator. Think of it as your personal job search assistant. You have already learned how to build Spring Boot APIs (Lessons 11–15), and you just finished setting up MySQL (Lesson 22). Now it is time to combine everything you know into a cohesive, professional-grade application. Every skill you have built so far — HTML, CSS, JavaScript, Java, Spring Boot, SQL — comes together here.

Why a job search app? Because learning to code is only half the battle. You also need to find a job. Resumator solves both problems at once: you practice your development skills while building a tool that helps you land your first role. When you sit down for an interview and someone asks "What have you built?", you will have a real, working application to show them — one that demonstrates API integration, database management, full-stack architecture, and practical problem-solving.

In this first lesson, we are going to plan the entire project and set up the foundation. By the end of today, you will have a fully configured Spring Boot project connected to a MySQL database and ready to start accepting code. Think of this lesson as laying the foundation of a house — it is not the most glamorous part, but nothing else works without it.

Part 2 — What Resumator Does

Before we write a single line of code, let us clearly define what Resumator will do when it is finished. Professional developers always start by understanding the requirements before jumping into code. This is a habit worth building now.

That is the complete application. It may sound simple, but building it will teach you how real applications are structured. You will work with external APIs, handle HTTP requests and responses, manage a database, and build a frontend that ties it all together. These are the exact same skills you will use every day as a professional developer.

Part 3 — Architecture Overview

Every application has an architecture — a plan for how the different parts fit together. Before you start building, you need to understand the big picture. Resumator has three main components, and they talk to each other in a specific order.

When a user searches for jobs, the data flows like this:

Here is what happens step by step. The user types a search query into a form in their browser. The browser sends that query to your Spring Boot backend server. Your Spring Boot server then calls the JSearch API (an external job search service) with that query, receives the results, and passes them back to the browser for display. Your Spring Boot server acts as a middleman between the browser and the external API. This is a very common pattern in web development — your backend talks to external services on behalf of your frontend.

When a user favorites a job, the data flows differently:

The user clicks "Save" on a job listing in the browser. The browser sends the job data to your Spring Boot server. Your server then stores the job in your MySQL database. When the user wants to see their saved jobs, the flow reverses: Spring Boot reads from MySQL and sends the data back to the browser.

Part 4 — Setting Up the Spring Boot Project

You have done this before in Lesson 12 when you created the contact-api project. The process is the same, but this time we are choosing different dependencies because Resumator has different needs. Head over to start.spring.io and configure the project with the following settings.

Now for the dependencies. Click "Add Dependencies" (or press Ctrl+B) and add the following three dependencies. Each one serves a specific purpose:

Double-check that all three dependencies are listed, then click "Generate". Download the resumator.zip file, unzip it, and open the resumator folder in your code editor (VS Code or IntelliJ IDEA). If you are using IntelliJ, it will detect the Maven project and begin downloading the dependencies automatically.

Once the project is open, take a quick look at the generated pom.xml file. You should see all three dependencies listed. Here is what the relevant section looks like:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Notice the <scope>runtime</scope> tag on the MySQL driver. This tells Maven that the driver is only needed when the application runs, not when compiling your code. This is because your code never directly references MySQL-specific classes — Spring Data JPA provides an abstraction layer. Also notice that Spring Boot included a test dependency automatically. You do not need to do anything with it right now, but it is there when you are ready to write tests.

Part 5 — Creating the MySQL Database

In Lesson 22, you installed MySQL and learned how to use the MySQL command-line client. Now you are going to create a dedicated database and user for Resumator. This is a best practice in professional development — every application gets its own database and its own database user with specific permissions. You never want your application connecting as the root user.

Open your terminal and connect to MySQL as the root user:

mysql -u root -p

Enter your root password when prompted. Once you are connected, run the following SQL commands one at a time:

CREATE DATABASE resumator;
CREATE USER 'resumator_app'@'localhost' IDENTIFIED BY 'your_password_here';
GRANT ALL PRIVILEGES ON resumator.* TO 'resumator_app'@'localhost';
FLUSH PRIVILEGES;

Let us break down each command:

• CREATE DATABASE resumator; — Creates a new, empty database called resumator. All of your application's tables will live inside this database.
• CREATE USER 'resumator_app'@'localhost' ... — Creates a new MySQL user named resumator_app that can only connect from your local machine (localhost). Replace your_password_here with an actual password of your choosing. Write it down — you will need it in the next step.
• GRANT ALL PRIVILEGES ON resumator.* ... — Gives the resumator_app user full access to the resumator database, but only that database. This user cannot see or modify any other databases on your MySQL server.
• FLUSH PRIVILEGES; — Tells MySQL to reload the permission tables so the new user's access takes effect immediately.

You can verify everything worked by running these commands while still logged into MySQL:

SHOW DATABASES;
-- You should see "resumator" in the list

SELECT User, Host FROM mysql.user WHERE User = 'resumator_app';
-- You should see one row: resumator_app | localhost

Once you have confirmed the database and user exist, type exit; to leave the MySQL client.

Part 6 — Configuring application.properties

Now you need to tell Spring Boot how to connect to your MySQL database. Open the file src/main/resources/application.properties. This file is currently empty. Add the following configuration:

# ===== Database Configuration =====
spring.datasource.url=jdbc:mysql://localhost:3306/resumator
spring.datasource.username=resumator_app
spring.datasource.password=your_password_here
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# ===== JPA / Hibernate Configuration =====
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

# ===== Server Configuration =====
server.port=8080

# ===== JSearch API Configuration =====
jsearch.api.key=YOUR_API_KEY_HERE
jsearch.api.url=https://jsearch.p.rapidapi.com

Let us go through each section:

Database Configuration: The spring.datasource.url tells Spring Boot where to find your MySQL database. The format is jdbc:mysql://host:port/database_name. Since MySQL runs on your local machine on port 3306 (the default), and your database is called resumator, the URL is jdbc:mysql://localhost:3306/resumator. The username and password are the ones you created in the previous step. The driver class name tells Spring Boot which JDBC driver to use for the connection.

JPA / Hibernate Configuration: The spring.jpa.hibernate.ddl-auto=none setting tells Hibernate (the JPA implementation that Spring Boot uses) not to automatically create or modify your database tables. This means you will manage your database schema yourself. The spring.jpa.show-sql=true setting prints every SQL query that Hibernate generates to the console, which is incredibly helpful for learning and debugging. The dialect setting tells Hibernate that you are using MySQL so it generates MySQL-compatible SQL.

Server Configuration: The server.port=8080 sets the port that your embedded Tomcat server will listen on. Port 8080 is the Spring Boot default, so this line is technically optional, but it is good practice to be explicit about your configuration.

JSearch API Configuration: These are custom properties that you will read from your Java code. The jsearch.api.key will hold your RapidAPI key (we will set this up in the next section), and jsearch.api.url is the base URL for the JSearch API. Custom properties like these are a clean way to keep configuration values out of your Java code.

Part 7 — Signing Up for the JSearch API

Resumator searches for real job listings using an external service called JSearch, which is available through RapidAPI. RapidAPI is a marketplace where developers can discover and connect to thousands of APIs. JSearch aggregates job postings from across the internet — LinkedIn, Indeed, Glassdoor, and many more — and makes them available through a single, simple API.

The JSearch free tier gives you 500 requests per month, which is more than enough for development and personal use. Here is how to set it up:

1. Create a RapidAPI account. Go to rapidapi.com and sign up for a free account. You can use your email or sign in with GitHub or Google.
2. Find JSearch. Once logged in, search for "JSearch" in the RapidAPI search bar. Click on the JSearch API by OpenWeb Ninja. You should see the API documentation page with endpoints like /search, /search-filters, and /job-details.
3. Subscribe to the free tier. Click the "Pricing" tab and select the Basic (Free) plan. This gives you 500 requests per month at no cost. You may be asked to enter a credit card for verification, but you will not be charged on the free tier.
4. Get your API key. After subscribing, go back to the API's "Endpoints" tab. In the code snippets section on the right side, look for the header labeled x-rapidapi-key. The value next to it is your API key — a long string of letters and numbers. Copy this key.
5. Add the key to application.properties. Go back to your application.properties file and replace YOUR_API_KEY_HERE with the key you just copied.

Let us add the .gitignore entry now. Open the .gitignore file in your project's root directory (Spring Initializr created one for you) and add this line at the bottom:

# Sensitive configuration
src/main/resources/application.properties

Then create a copy of your properties file as a template for other developers:

# ===== Database Configuration =====
spring.datasource.url=jdbc:mysql://localhost:3306/resumator
spring.datasource.username=resumator_app
spring.datasource.password=YOUR_DB_PASSWORD_HERE
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# ===== JPA / Hibernate Configuration =====
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

# ===== Server Configuration =====
server.port=8080

# ===== JSearch API Configuration =====
jsearch.api.key=YOUR_RAPIDAPI_KEY_HERE
jsearch.api.url=https://jsearch.p.rapidapi.com

Save this as src/main/resources/application.properties.example. This file is safe to commit to Git because it contains no real secrets — just placeholders that tell other developers what values they need to provide.

Part 8 — Project Package Structure

When you build a small project with one or two files, organization does not matter much. But as your application grows, you need a clear structure so you can find things quickly. Professional Spring Boot applications follow a standard package layout that separates code by responsibility. Here is the structure you are going to use for Resumator:

src/main/java/org/codersfarm/resumator/
    ResumatorApplication.java          <-- Main entry point (already generated)

    controller/                        <-- Handles HTTP requests
        JobSearchController.java
        FavoriteController.java

    service/                           <-- Business logic
        JobSearchService.java
        FavoriteService.java

    model/                             <-- Data structures (entities)
        Job.java
        FavoriteJob.java

    repository/                        <-- Database access
        FavoriteJobRepository.java

Each package has a specific responsibility:

This pattern is called layered architecture, and it is used by virtually every professional Spring Boot application. The flow always moves in one direction: Controller → Service → Repository → Database. Controllers never talk directly to the database, and repositories never handle HTTP requests. Each layer does one job and does it well.

For now, just create the empty package folders. In your src/main/java/org/codersfarm/resumator/ directory, create four new folders:

• controller
• service
• model
• repository

Part 9 — Verify Your Setup

It is time to make sure everything is wired up correctly. Open your terminal, navigate to the resumator project directory (the folder that contains pom.xml), and run the application:

Mac or Linux:

./mvnw spring-boot:run

Windows:

mvnw.cmd spring-boot:run

Watch the terminal output carefully. You are looking for a line like this near the end:

Started ResumatorApplication in X.XXX seconds

If you see that message, congratulations — your project is correctly configured and running. The Spring Boot embedded Tomcat server is live on port 8080, and your application has successfully connected to the MySQL database.

If you see errors instead, here are the most common issues and their fixes:

Once the application starts successfully, press Ctrl+C in the terminal to stop it. Your foundation is solid and ready for the next lesson.

Quiz — Check Your Understanding

Lesson Summary

You accomplished a lot in this lesson. Let us recap everything you did:

• You learned what Resumator is: a job search assistant that searches for real jobs, lets you browse results, favorite listings, and manage saved jobs.
• You planned the architecture: Browser → Spring Boot → JSearch API for searching, and Browser → Spring Boot → MySQL for saving favorites.
• You created a new Spring Boot project at start.spring.io with three dependencies: Spring Web, Spring Data JPA, and MySQL Driver.
• You created a MySQL database called resumator and a dedicated user with the right permissions.
• You configured application.properties with database connection settings, JPA configuration, and API credentials.
• You signed up for the JSearch API on RapidAPI and learned how to keep your API key secure.
• You organized your project into the four-package pattern: controller, service, model, and repository.
• You verified that the application starts without errors.

The foundation is laid. In the next lesson, you will bring Resumator to life by building the Job Search API — a set of endpoints that call the JSearch API and return real job listings. You will write your first service class, learn how to make HTTP calls from Spring Boot, and parse JSON responses. The real fun starts now.