SP-2 Backend Portfolio

On 3rd semester, the focus shifts from learning isolated technologies to building something real over time.

Instead of small, disconnected assignments, you will:

• Build one coherent backend application throughout the semester

• Gradually extend it as new Java technologies are introduced

• Document your progress in a developer portfolio

• End the semester with something you can proudly show to:

  • examiners
  • future employers
  • yourself

This project mirrors how software is built in practice: incrementally, with new requirements, new technologies, and continuous reflection.

At the exam, you will hand in one link:

• A GitHub repository containing:
  • Your Java backend application
  • Your portfolio (blog-style documentation)

There is no separate report.

Your repository is your exam hand-in.

You will:

1. Choose an application idea of your own
2. Build it incrementally over the semester
3. Each week:
   • Extend the application with new technologies
   • Write a short portfolio/blog post describing:
     • what you built
     • what you learned
     • challenges and decisions

Every Friday is dedicated project time:

• You work on your application
• You integrate that week’s new technology
• You reflect and document your progress

The goal after week 10 is a production-ready backend API.

During these weeks, you will gradually add:

• Java + Maven project structure
• REST API & endpoints
• JPA / database persistence
• External API integration
• Validation & error handling
• Integration tests
• JWT-based authentication & authorization
• Configuration & environment variables
• Deployment

Each new topic is added to the same application — not a new one.

• Polishing and stabilizing the application
• Improving documentation
• Reflecting on architectural decisions
• Making sure the project tells a clear story

Your portfolio is not a marketing website.

It is a developer log / learning journal, stored inside your repository.

Think of it as:

• “This is how my project evolved”
• “This is how I think as a developer”
• “This is how I learn new technologies”

• What did I add this week?
• Which new technology did I use?
• Why did I structure it this way?
• What worked well?
• What was difficult or confusing?
• What would I improve next time?

Short, honest, technical reflections are better than polished marketing text.

Your application can be anything, as long as it makes sense as a backend API.

• Users (accounts, roles, permissions)
• Data that changes over time
• CRUD operations
• Business rules
• Possibility for authentication & security
• Potential for future expansion

• Event or booking system
• Fitness or habit tracking API
• Recipe or meal planning backend
• Learning platform or quiz system
• Simple marketplace or listing service
• Personal finance or budgeting API
• Game stats or leaderboard backend

💡 Important: The idea does not need to be big or original. A simple, well-structured system beats a complex unfinished one.

You are expected to start small.

Week 1 might only have:

• One entity
• A few CRUD DAO operations

That’s fine.

Over the semester, your application will naturally grow as you add:

• database relationships
• authentication
• validation
• tests
• deployment concerns

This is exactly how real systems evolve.

You will be evaluated on:

Technical quality

• correct use of Java technologies
• clean structure
• reasonable architecture

Progress over time

• consistent weekly development
• visible evolution in Git history

Reflection

• understanding of what you built
• ability to explain choices and trade-offs

Professionalism

• readable code
• meaningful commits
• clear documentation

This is not about perfection. It is about learning, reasoning, and progression.

To get going, you should:

1. Brainstorm 2–3 possible application ideas

2. Pick one simple core use case

3. Create a GitHub repository

4. Set up:

   • basic Java project structure
   • README with:
     • project idea
     • initial scope
     • rough vision

5. Write your first portfolio post:

   • Why did I choose this idea?
   • What do I want this system to become?

You are not locking yourself in forever — ideas can evolve.

This project is designed to help you answer a very real question:

“Can I actually build and evolve a backend system?”

By the end of the semester, the answer should be yes — and you will have proof.

If you get stuck, that’s part of the process. If you change direction slightly, that’s normal. What matters is that you build, reflect, and keep moving forward.

Let’s build something worth showing