DEV Community: Mosopefoluwa Adebawojo

Building Auto-Clearance: Automating NYSC Monthly Clearance Document Generation for PPAs

Mosopefoluwa Adebawojo — Mon, 29 Dec 2025 11:50:17 +0000

Project Overview

Auto-Clearance is an automated solution designed to streamline the Human Resources (HR) workflow for clearing National Youth Service Corps (NYSC) members (corpers) working in their organization.
Every month, each corper is required to present a clearance document from their Place of Primary Assignment (PPA). Auto-Clearance eliminates the repetitive manual process of creating these documents by automating the generation of personalized clearance letters, saving both time and organizational resources.

Problem Statement

NYSC mandates that all corpers submit a monthly clearance document issued by their respective PPAs. At many organizations, this document is manually edited for each corper using a template.
This approach is:

Time-consuming
Repetitive
Prone to human error

Auto-Clearance addresses this challenge by automating the generation and delivery of clearance documents based on each corper’s clearance request and approval status.

Tech Stack

Backend: Java 21 with Spring Boot 3
Frontend: React
Database: MySQL - Stores data related to PPAs, users (Global Admin, Superadmin, Admin, Corper), units, and clearance requests

Roles & Responsibilities

The Auto-Clearance system supports four distinct user roles, each with clearly defined responsibilities:

1. Global Admin

Manages multiple PPAs
Creates PPAs and assigns a Superadmin to each
Seeded into the database on the first application startup
On subsequent startups, the system checks for an existing Global Admin to prevent duplication

2. Superadmin (PPA HR)

Each PPA has exactly one Superadmin
Manages units and assigns unit heads (Admins)
Reviews clearance requests after unit head approval
Performs final approval or rejection

3. Admin (Unit Head)

Manages a specific unit within a PPA
Reviews and approves or rejects clearance requests from corpers within their unit

4. Corper (NYSC Member)

Submits monthly clearance requests
Receives the clearance letter after approval by both the unit head and Superadmin

Workflow

The Global Admin creates a PPA and assigns a Superadmin

A. The Superadmin:

Creates units within the PPA
Assigns unit heads (Admins)
Adds corpers to units

B. A corper submits a clearance request (status: PENDING)

C. The unit head (Admin) reviews the request:

If approved → status changes to LEVEL_ONE
If rejected → status changes to REJECTED

D. The Superadmin reviews the request:

If approved → status changes to CLEARED
If rejected → status changes to REJECTED

Once fully approved, the system generates the clearance document for the corper which can be viewed, downloaded or printed from the superadmin’s dashboard. Here's an example:

Clearance Request Statuses

PENDING – Initial state after submission
LEVEL_ONE – Approved by the unit head
CLEARED – Fully approved by the Superadmin
REJECTED – Rejected at any approval level

Challenges & Key Decisions

One of the major challenges I faced while developing Auto-Clearance was deciding whether to customize the application for one organization or make it scalable for multiple organizations. I initially thought of building a single-use version for one PPA, but I realized that there could be other organizations and PPAs who could benefit from this solution.
After weighing the options, I decided to extend the application to support multiple PPAs. This led to the introduction of the Global Admin role, which allows management of multiple PPAs and facilitates scalability across different organizations.

Final Thoughts

This project has been an incredible learning experience. A special thanks to Ekemini Eduok for taking the lead on the frontend development of this project and allowing me to focus more on building the backend.

Fix JSP Not Rendering in Spring Boot (MVC + IntelliJ Guide)

Mosopefoluwa Adebawojo — Wed, 11 Jun 2025 22:09:01 +0000

When I began learning Spring MVC, one of the hurdles I encountered was rendering .jsp (Java Server Pages) in a Spring Boot project using IntelliJ IDEA Community Edition. Unlike other IDEs that may offer built-in support for enterprise features like JSP rendering, the Community Edition requires some extra configuration.

After countless attempts and piecing together various resources, I finally figured out a working solution, and I’m here to share it with you in a step-by-step guide.

✅ Step 1: Create a New Maven Web Project

Open IntelliJ IDEA Community Edition
Create a new Project
Select Maven Archetype (from the left corner)

Name your project – e.g., GetJSPWorking

Choose Maven as your build tool (if not already selected)
Select the archetype: maven-archetype-webapp

Click Create

At this point, you should see the following structure:

✅ Step 2: Setup the Project Structure

Create a directory named java inside src/main/.
Inside java, create your base package, e.g., com.example.

✅ Step 3: Configure the pom.xml File

Replace the default pom.xml content with the following:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.4.6</version>
    <relativePath/>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>GetJSPWorking</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <!-- Spring Boot Web -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- JSP Support -->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
      <scope>provided</scope>
    </dependency>

    <!-- JSTL Support -->
    <dependency>
      <groupId>jakarta.servlet.jsp.jstl</groupId>
      <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
      <version>3.0.0</version>
    </dependency>

    <!-- Dev Tools -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </dependency>

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

  <build>
    <finalName>TestWebApplicationJSP</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

NB: Don’t forget to update your groupId and artifactId to match your own.

✅ Step 4: Create the Application Entry Point

Inside your com.example package, create the main application class:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

✅ Step 5: Create a Controller

Also inside com.example, create a controller:

package com.example;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class GetJSPWorkingController {

    @RequestMapping("/get-jsp")
    public String getJsp() {
        return "index"; // Refers to index.jsp
    }
}

✅ Step 6: Add Your JSP File

Inside src/main/webapp/WEB-INF/, create a folder named jsp.
Inside jsp, create a file named index.jsp.
Paste this simple HTML code:

<html>
  <body>
    <h2>Hello JSP!</h2>
  </body>
</html>

✅ Step 7: Configure View Resolver

Create a file named application.properties inside src/main/resources/ with the following contents:

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
spring.web.resources.static-locations=classpath:/static/

✅ Step 8: Build and Run the Application

Open the Maven tab in IntelliJ.

Run the following commands:

mvn clean install

mvn spring-boot:run

Visit http://localhost:8080/get-jsp in your browser.

If everything was set up correctly, you should see:

Conclusion

Getting JSP to work with Spring Boot in IntelliJ Community Edition can feel tricky, but it’s totally doable. If you're like me and got stuck along the way, I hope this guide clears up the confusion and helps you render your JSP views without a hitch.

N.B: This setup is ideal for learning purposes. In production, it’s recommended to use Thymeleaf or another modern template engine, as JSP is gradually being phased out of modern Spring applications. However, understanding how to configure JSP is valuable for legacy systems and academic projects.