Full-Stack FinTech App: Spring Boot 4, React, Devops & CI/CD

Create a new GitHub repository for the backend, clone via SSH or HTTP, and add a README and .gitignore with public visibility to enable GitHub CI/CD and Spring Initializr.

Initialize a Spring Boot app using start.spring.io with Spring Web, JPA, MySQL, Lombok, validation, mail sender, and thyme leaf. Generate the project and import into IntelliJ for a Maven build.

Run the app and fix a database connection error by adjusting the pom.xml Lombok plugins and removing duplicates. Prepare to add dependencies such as json web token and s3 sdk.

Add external dependencies to enable authentication, DTO conversion, and cloud storage in the full-stack finTech app. Use JWT, model mapper, Jackson, and S3 via Maven, then refresh dependencies.

Connect your Spring Boot app to a local bank database by configuring the server port, data source URL, and credentials, then run and verify with the default Spring Security password.

Move sensitive database credentials into a .env file and reference them in application properties via spring.config.import, using local and production db URLs, usernames, passwords, and port to secure deployments.

Commit and push code to GitHub while managing ignores, staging changes, and syncing updates using git status, git add, git commit, and git push for a clean fintech app repository.

Structure a Java project into modules—accounts, users, transactions, and notifications—each with controller, dto, entity, repo, and service, plus config, enums, exceptions, response, rule, security, AWS, and audit dashboard.

Configure a Spring Boot app with an app config class, exposing a Thymeleaf template engine and a model mapper, and set template resolver prefix, suffix, and utf-8 encoding.

Create enums for account status, account type, currency, notification type, transaction status, and transaction type to support a robust fintech app.

Define the role entity as a JPA object mapped to the rows table, with an auto-generated identity id, and a Lombok-powered non-blank, unique name field.

Create a role repository that extends JPA repository for the role entity with a long primary key and a find by name method returning an optional role.

Define a user entity with id, first name, last name, phone, email, password, profile URL, active flag, timestamps; configure a many-to-many relationship with roles via users_table and map accounts.

Define the user dto with json include not null to emit profile url, ignore password in responses, and use json managed reference to prevent circular user-account dependencies.

Create a user repository interface that extends the JPA repository and defines a findByEmail method returning an optional user to support authentication.

Create a password reset code entity linked to a user, with a unique code, expiry date, and a used flag, enabling secure forgot-password flow with expiration checks.

Design and implement a password reset repository using JPA, with a find by code method and a delete-to-reuse prevention workflow, ensuring codes are invalidated after password reset.

Create a password reset request DTO to collect email, code, and new password, using json ignore properties to support both forgot password and reset password flows.

Create a registration request data class to collect user data for account registration, including first name, last name, phone number, email, and password, per the user auth details.

Explore login request and response DTOs that use email and password to return a token and user data, plus update password requests for authenticated users.

Define the account entity with id, account number, balance default zero, currency, and account type; relate to a user (many-to-one via user_id) and to transactions (one-to-many) with cascade all.

Create an account dto by refining nested user and transaction details with json back reference and json ignore to prevent circular dependencies in responses.

Define the account repository interface that extends JpaRepository<Account, Long>, with methods findByAccountNumber and findByUserId, enabling optional account lookup and listing a user's accounts.

Define a transaction entity with id, amount (big decimal), type (transfer, deposit, withdrawal), date, description, status, and a many-to-one link to account, including source and destination accounts for transfers.

Design the transaction dto with fields like id, amount, type, date, description, status, and accounts, and annotate with json back reference to prevent circular dependencies while supporting transfer requests.

Define a transaction request data object that supports deposit, withdrawal, and transfer with a transaction type enum, amount as BigDecimal, account numbers, and an optional destination account number.

Create a transaction repository extending JPA repository, with methods to find by account number returning a page or a list of transactions, leveraging account relationship.

Define the notification entity with id, subject, recipient, body, type, user, and createdat, map it to the notifications table, and implement a many-to-one relation to users.

Create a notification dto class with annotations to capture id, subject, recipient, body, type, and creation date, plus template name and template variable to populate a static html email template.

Create a notification repository interface in the notification package that extends the JPA repository for the notification entity with a long primary key, without adding custom methods.

Define a generic response class with a status code, message, and data of a generic type, using json include not null and a meta map for pagination.

Create specific exception classes for not found, bad request, insufficient balance, and invalid transaction. Implement a controller advice to return a categorized, custom error response on exceptions.

Implement a global exception handler with controller advice to catch all controller errors and return a structured response via response entity, including 404 for not found.

Implement a robust exception handler in Spring Boot 4 that captures insufficient balance, invalid transaction, and bad request exceptions, mapping them to bad request responses for clear error handling.

Intercept requests at the authentication module before they reach the controller, and return a 401 unauthorized json error via a custom authentication entry point using an object mapper.

Implement a custom access denied handler as a reusable component, distinguishing 401 unauthorized from 403 forbidden, and enforce route permissions for admin vs customer access.

Implement a security layer with a JWT service to generate and authenticate tokens, and define public versus role-based routes with a 30-character secret and 30-day expiration in configuration.

Correct the account entity relationship by changing the user reference from many-to-many to many-to-one, enabling a user to have multiple accounts and ensuring the app runs without errors.

Create an auth user class implementing Spring Security's user details to feed role, password, and email into authentication. Map roles to authorities and use email as the username.

Implement a custom user details service in Spring Security by wiring the user repository, loading users by email, handling email not found errors, and building the auth user.

Learn to implement a token service in a security package that generates, validates, and extracts information from JWT tokens using a secret key, expiration settings, and an email-based subject.

implement a token service that extracts claims from a jwt, verifies and validates tokens, retrieves the username from the token, and handles expiration with a long expiration value.

Explore implementing an auth filter (once per request) for a fintech app, extracting bearer tokens from authorization headers, wiring a token service and custom user details service to secure requests.

Implement a jwt-based auth filter that validates a token, extracts the email, loads user details, builds an authentication token, and forwards requests to the next filter in the chain.

define a security filter chain to expose public routes and protect others, disable csrf, permit api/auth endpoints, and enforce stateless jwt-based authentication with a custom denial handler and entry point.

Implement a password encoder bean from Spring Security, encode passwords on registration, decode on login, and expose an authentication manager bean via authentication configuration for security filters.

Configure cors in Spring by creating a course config bean, import from Spring framework, set allowed origins and methods for development, adjust max age, and register a cors filter.

Configure Gmail smtp settings in your application properties to enable sending emails, including spring.mail.username, spring.mail.password (app password), smtp.gmail.com, port 587, and tls with smtp.auth.

Enable two-factor authentication, generate a Google app password, and configure SMTP in a Spring Boot 4 project using the Spring Boot starter mail to send emails.

Build a notification service to send emails using a Java mail sender, template engine, and notification repository, saving user-linked notifications to the database and enabling asynchronous processing.

An in-depth look at building a notification service that sends emails with optional templates, handles HTML content, logs errors, and persists sent notifications to a database.

Set up a command line runner to test sending a dummy email via the notification service using a built notification DTO with recipient, subject, and body.

Define the role service interface in the role package's service layer, with methods to create (using a role request), update, get all, and delete roles, all returning a response.

Implement the role service with a new role service implementation class and a role repository; validate existence before create or update, handle not found, then return a built response.

Implement role service operations in Spring Boot: fetch all roles via repository, return structured responses, and handle delete by id with not found checks and success messages.

design a role controller secured with pre authorized admin access, exposing create, update, get all, and delete endpoints for roles in a spring boot api.

Test the role API with Postman: create roles (admin, customer, auditor) via POST /api/roles with a JSON body, handle authentication requirements, and retrieve all roles via GET /api/roles.

Develop the auth interface for the full-stack fintech app by implementing an auth service with register, login, forgot password, and reset password via reset code, with admin-only api access.

Describe implementing the auth service for user registration, including role handling, email checks, password encoding, token generation, user persistence, account creation, and welcome emails.

Set up a two-step email workflow sending a welcome email and an account creation email via a builder-pattern notification DTO with template-driven variables for the user's name and account details.

Implement a login method that validates email existence and password, generates a token, and returns a login response with user roles for secure front-end caching.

Create and preview HTML email templates for account creation, including welcome and account creation templates, with placeholders for name, account type, account number, and currency.

Design and implement a forgot password flow that emails users a unique, five-character alphanumeric reset code, generated by a dedicated code generator and verified for uniqueness before sending.

Demonstrate the forgot password flow: validate user by email, delete old reset codes, generate a five-hour expiration reset code, and send a reset link via email.

Explore implementing a reset password method with transactional annotation to ensure atomic updates across databases, including code validation, password encoding, user update, code deletion, and update emails.

Create an auth controller as a rest controller mapped to /api/auth, wiring in the auth service to implement register, login, forget password, and reset password with validation.

Demonstrates end-to-end authentication api testing for registration, login, and password flows, including email notifications, token generation, and role assignment in a fintech app.

Define a user service interface to fetch the current user's profile, and to update passwords and profile pictures. Support paginated user lists and profile updates via multipart uploads.

Implement get current login user and paginated user retrieval in a Spring Boot 4 user service, using security context, user repository, model mapper, and notification and password encoder.

Learn to securely update the currently logged-in user's password by validating old and new inputs, encoding the new password, updating the user record, and sending a password change notification email.

Implement profile picture upload in the backend by setting a storage path, creating the directory, removing old pictures, generating a unique file name, and updating the user profile URL.

Develop a Spring Boot users controller under /api/users, enabling paginated retrieval of users, a /me endpoint for the current user, and endpoints to update password and profile picture via multipart.

Test the users api by calling /api/users with an admin bearer token, verify profile retrieval at /profile/me, and explore profile picture upload and password update with token authentication and pagination.

Define the account service interface with create, get, and close methods, then implement a transactional service using the account repo, user service, model mapper, and a random account number generator.

Generate a unique ten-digit account number starting with six via a private method, ensure uniqueness, then build and save the account with type, usd, zero balance, and active status.

Fetch the current user’s accounts, map them to account dtos, and return a structured response. Then verify ownership, require zero balance, close the account, and save changes.

Develop an account controller with rest annotations at /api/accounts, and use the account service to get all accounts, get my account by token, and close an account by number.

Test the account creation workflow triggered by user registration, verify the generated account number and email notifications, and inspect account retrieval via accounts/me with a bearer token.