Welcome to my first blog post

This is the very first entry in my project roadmap, and I want to use it to reflect on what we are building, which technologies we are using, and where we currently stand in the process.

Our project is a full-stack application built around a Spring Boot REST API connected to a MySQL database. On top of that, we have a separate frontend written in HTML, CSS, and JavaScript. The frontend communicates with the backend via API calls, which means the two parts are fully decoupled.

What we have used so far:

Spring Boot (Java): 
Provides the backbone of the application. It handles API endpoints, business logic, and connects to the database.

MySQL: 
Stores all of our data in a structured way. We have worked on database design, relationships, and queries to ensure the backend delivers the correct data.

JPA: 
To control our SQL data

HTML, CSS, JavaScript: 
Build the interface that users interact with. JavaScript (via fetch) pulls data dynamically from the REST API and updates the DOM without needing a full page refresh.

How we have used it
The backend exposes endpoints for creating, reading, updating, and deleting data (CRUD). 

For example, blog posts and user information can be managed entirely through these APIs. 

On the frontend, we have implemented dynamic rendering so that posts, comments, and user profiles are fetched directly from the backend and displayed in real time.

We are also experimenting with JWT tokens for authentication, giving us secure login and role-based access. On top of that, we are learning about file uploads (such as profile images), and integrating them with our database structure.

Where we are in the process
Right now, the core features are in place:
Users can be created and authenticated.
Blog posts can be created, read, and displayed.
Comments are fetched dynamically and rendered directly into the page.

The next steps involve refining the user experience, handling images properly across backend and frontend, and preparing for deployment. 

We are also looking into Docker for containerization, so we can run the database, backend, and potentially the frontend in a clean, reproducible environment.

This blog marks the first step in documenting the journey — from raw code to a running, deployed project. The road ahead includes polishing features, setting up CI/CD, and ensuring the system is robust enough for real users.