Skip to content
BSWEN
Blog

What Should Be My First Spring Boot Project? (Beginner Guide)

Cowrie
Cowrie
Dev @ Bswen

The Problem

I wanted to learn Spring Boot. I asked Reddit: “What should be my first Spring Boot project?” The answers varied - some said Hello World, others suggested Todo apps, and a few recommended jumping straight into CRUD applications.

I tried the CRUD approach first. I generated a project, added database dependencies, created entities, and started coding. Within an hour, I was drowning in unfamiliar concepts: @Entity, @Repository, @Autowired, Hibernate dialects, connection pools. I had no idea what any of these meant.

I had made the classic beginner mistake: skipping the foundation.

Why Hello World Beats CRUD for Beginners

The Reddit community gave me the key insight. Start simple, then add complexity step by step:

Recommended Learning Progression
Hello World (learn annotations, project structure)
    |
REST Endpoint (learn HTTP methods, JSON)
    |
Multiple Endpoints (learn routing, path variables)
    |
Data Models (learn POJOs, serialization)
    |
Database Integration (learn JPA, repositories)
    |
Full CRUD Application (combine all concepts)

When you jump straight to CRUD, you try to learn all these concepts at once. That’s why beginners get overwhelmed.

A Hello World app teaches you the essentials first:

  • Spring Boot annotations: @SpringBootApplication, @RestController, @GetMapping
  • Project structure: where to put controllers, services, configuration
  • Build tools: Maven or Gradle basics
  • Application lifecycle: how Spring Boot starts and runs

Once you understand these, adding database connectivity becomes manageable.

Phase 1: Hello World (Where You Should Start)

Step 1: Generate Your Project

Visit Spring Initializer. This is the official tool for creating Spring Boot projects. Configure it like this:

Spring Initializer Configuration
Project: Maven
Language: Java
Spring Boot: 3.5.x (latest stable)
Group: com.example
Artifact: hello-world
Package name: com.example.helloworld
Packaging: Jar
Java: 21 (or 17 if you prefer)


Dependencies: Spring Web (for REST endpoints)

Click Generate and extract the ZIP file. You now have a complete Spring Boot project.

Step 2: Create Your First Controller

Open src/main/java/com/example/helloworld/HelloWorldApplication.java and add a simple REST endpoint:

HelloWorldApplication.java
package com.example.helloworld;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@SpringBootApplication
public class HelloWorldApplication {


    @GetMapping("/")
    public String home() {
        return "Hello, Spring Boot!";
    }


    @GetMapping("/greeting")
    public String greeting() {
        return "Welcome to your first Spring Boot application!";
    }


    public static void main(String[] args) {
        SpringApplication.run(HelloWorldApplication.class, args);
    }
}

Notice the annotations:

  • @SpringBootApplication marks this as a Spring Boot application
  • @RestController tells Spring this class handles HTTP requests
  • @GetMapping("/") maps the root URL to the home() method

Step 3: Run and Test

Terminal
# Navigate to project directory
cd hello-world


# Run with Maven
./mvnw spring-boot:run


# Test endpoints
curl http://localhost:8080/
# Output: Hello, Spring Boot!


curl http://localhost:8080/greeting
# Output: Welcome to your first Spring Boot application!

You just created a working Spring Boot application. Take time to understand what each annotation does before moving forward.

Phase 2: REST API with JSON Response

Once Hello World works, add a REST API that returns JSON:

ApiController.java
package com.example.helloworld;


import org.springframework.web.bind.annotation.*;


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


@RestController
@RequestMapping("/api")
public class ApiController {


    private List<String> items = new ArrayList<>();


    @GetMapping("/items")
    public List<String> getItems() {
        return items;
    }


    @PostMapping("/items")
    public String addItem(@RequestBody String item) {
        items.add(item);
        return "Added: " + item;
    }
}

New concepts introduced:

  • @RequestMapping("/api") - all endpoints in this class start with /api
  • @PostMapping - handles HTTP POST requests
  • @RequestBody - extracts the request body
  • List<String> - Spring automatically converts this to JSON

Test the endpoints:

Terminal
# Get all items (empty list at first)
curl http://localhost:8080/api/items
# Output: []


# Add an item
curl -X POST -d "Learn Spring Boot" http://localhost:8080/api/items
# Output: Added: Learn Spring Boot


# Get all items again
curl http://localhost:8080/api/items
# Output: ["Learn Spring Boot"]

Phase 3: Todo Application (In-Memory CRUD)

Now build a Todo application with full CRUD operations (Create, Read, Update, Delete). This introduces state management without database complexity:

TodoItem.java
package com.example.todo;


public class TodoItem {
    private Long id;
    private String title;
    private boolean completed;


    public TodoItem() {}


    public TodoItem(Long id, String title) {
        this.id = id;
        this.title = title;
        this.completed = false;
    }


    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public boolean isCompleted() { return completed; }
    public void setCompleted(boolean completed) { this.completed = completed; }
}
TodoController.java
package com.example.todo;


import org.springframework.web.bind.annotation.*;


import java.util.*;


@RestController
@RequestMapping("/api/todos")
public class TodoController {


    private List<TodoItem> todos = new ArrayList<>();
    private Long nextId = 1L;


    @GetMapping
    public List<TodoItem> getAll() {
        return todos;
    }


    @PostMapping
    public TodoItem create(@RequestBody TodoItem todo) {
        todo.setId(nextId++);
        todos.add(todo);
        return todo;
    }


    @PutMapping("/{id}")
    public TodoItem update(@PathVariable Long id, @RequestBody TodoItem updated) {
        todos.stream()
            .filter(t -> t.getId().equals(id))
            .findFirst()
            .ifPresent(t -> {
                t.setTitle(updated.getTitle());
                t.setCompleted(updated.isCompleted());
            });
        return todos.stream()
            .filter(t -> t.getId().equals(id))
            .findFirst()
            .orElse(null);
    }


    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id) {
        todos.removeIf(t -> t.getId().equals(id));
    }
}

New concepts:

  • @PathVariable - extracts values from the URL path
  • @PutMapping - handles HTTP PUT requests (updates)
  • @DeleteMapping - handles HTTP DELETE requests
  • POJOs (Plain Old Java Objects) - simple data classes with getters/setters

Test the Todo API:

Terminal
# Create a todo
curl -X POST -H "Content-Type: application/json" \
  -d '{"title":"Learn annotations"}' \
  http://localhost:8080/api/todos
# Output: {"id":1,"title":"Learn annotations","completed":false}


# Get all todos
curl http://localhost:8080/api/todos


# Update a todo
curl -X PUT -H "Content-Type: application/json" \
  -d '{"title":"Learn annotations","completed":true}' \
  http://localhost:8080/api/todos/1


# Delete a todo
curl -X DELETE http://localhost:8080/api/todos/1

Common Beginner Mistakes

I made these mistakes. You might too:

Mistake 1: Skipping basics to jump to advanced topics

Don’t start with Spring Security, JWT, or microservices. Master Hello World first, then REST API, then JPA, then Security - in that order.

Mistake 2: Copy-pasting without understanding annotations

Create a study list. Write down what each annotation does:

  • @SpringBootApplication - main application class
  • @RestController - handles HTTP requests
  • @GetMapping - maps GET requests
  • @Autowired - dependency injection (you’ll learn this later)
  • @Component - marks a class as a Spring bean

Mistake 3: Ignoring error messages

Spring Boot error messages are detailed and helpful. Read them before Googling. They often tell you exactly what’s wrong.

Mistake 4: Over-engineering

Keep it simple. One controller, one service, one repository. Don’t add Docker, Kubernetes, or multiple modules until you understand the basics.

What’s Next

After completing the Todo app with in-memory storage, you’re ready for database integration. The next steps:

  1. Add Spring Data JPA dependency in Spring Initializer
  2. Choose a database (H2 for development, PostgreSQL for production)
  3. Create @Entity classes that map to database tables
  4. Create @Repository interfaces for database operations
  5. Replace the in-memory List<TodoItem> with database persistence

This progression mirrors the Reddit community’s advice: start with understanding, then build complexity. The Hello World approach gives you the foundation needed before tackling database CRUD.

Summary

Your first Spring Boot project should follow this progression:

  • Phase 1: Hello World - learn annotations and project structure
  • Phase 2: REST API - learn HTTP methods and JSON serialization
  • Phase 3: Todo app (in-memory) - learn CRUD without database complexity
  • Phase 4: Database CRUD - combine all concepts with persistence

Every expert Spring Boot developer started with return "Hello World!";. The key is understanding each piece before adding the next.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: