Experience
Java Industry Immersion Trainee
Training Context
TESDA Java Preparation & Industry Immersion
Completed a Java-focused industry immersion at Spring Valley Tech following approximately two months of TESDA-related Java training and preparation.
The immersion served as an intensive practical phase where concepts learned during training were applied directly to full-system implementation work.
Main Project
Internal Records & Storage Tracking System
Designed and built a Dockerized internal records and storage tracking system using Spring Boot, React, Tailwind CSS, and PostgreSQL. The application was designed to digitize paper-based tracking of physical records or items as they moved between storage locations, users, and lifecycle states.
Problem Context
Physical Storage & Manual Tracking Challenge
The workflow being modeled involved physical items and records-such as files, books, inventory records, and stored physical materials-distributed across drawers, rooms, storage boxes, and designated storage locations.
The original workflow relied heavily on manual paper recording, creating challenges for item retrieval, tracking current location, identifying handling history, and auditing item statuses. The project aimed to make physical storage tracking structured, searchable, and verifiable.
Core Workflow
End-to-End Tracking Workflow
The system models the complete record lifecycle through a structured sequential process:
- Create Record: Register item metadata and physical properties into the database.
- Assign Storage Location: Associate the record with a specific room, box, or storage container.
- Generate / Associate Code: Link a unique QR code or barcode to the item record.
- Scan Item: Retrieve instant record details via camera or scanner input.
- Identify Record: Verify item identity, current location, and current state.
- Record Handler: Log the specific user performing or authorizing the transaction.
- Record Destination: Specify the new storage location or borrower destination.
- Update Status: Transition item lifecycle state in real time.
- Preserve Action History: Store an immutable audit trail of movements and state changes.
Scope & Ownership
Full-Stack Ownership
Owned the implementation across the application stack, from backend and database design through frontend, QR/barcode workflows, API documentation, and containerization.
Responsibilities encompassed system design, Spring Boot backend API development, React/Tailwind user interface implementation, PostgreSQL schema modeling, Swagger documentation, Docker configuration, and core workflow testing.
Architecture
Technology Stack & Components
Backend
- Java
- Spring Boot
- REST APIs
- Data Validation
Frontend
- React
- Tailwind CSS
- Record Forms
- Dashboard UI
Database
- PostgreSQL
- Relational Schema
- Audit Trail Storage
API & Environment
- Swagger / OpenAPI
- Docker
- Containerized Setup
Identification
QR & Barcode Identification
Implemented dual support for both QR codes and barcodes to identify physical records and items.
Upon scanning, the application instantly retrieves the corresponding item record, allowing handlers to log user actions, update destination locations, and record status changes directly within the item's movement history.
Lifecycle Tracking
Supported Lifecycle States
The system models physical record management across six core lifecycle states:
- Stored: Item is securely located in its assigned storage container/room.
- Checked / Taken Out: Item is actively borrowed or retrieved for use.
- Returned: Item has been returned to storage and verified.
- Moved / Transferred: Item has been permanently or temporarily relocated to a new storage area.
- Disposed: Item has reached the end of its retention period and is marked disposed.
- Lost / Missing: Item is unaccounted for during inventory audits.
Overview Interface
Functional Storage Dashboard
Implemented a functional dashboard providing quick summary counts across key storage and operational metrics:
- Total records and items registered in the system
- Storage location distribution and utilization
- Currently checked-out / taken items
- Disposed and archived records count
Engineering Rationale
Technical Decisions
Spring Boot Backend: Used Spring Boot to translate Java training into a complete backend application with structured APIs, persistence, validation, and record-management workflows.
React & Tailwind Frontend: Built a clean, responsive single-page frontend using React and Tailwind CSS, separating presentation logic from backend API workflows.
PostgreSQL Relational Storage: Selected PostgreSQL because the workflow depended on structured relationships between records, locations, statuses, and actions.
Docker Containerization: Containerized the application with Docker to make the development environment more reproducible and easier to run consistently.
Swagger API Documentation: Documented and inspected backend endpoints through Swagger to make the API easier to understand and test during development.
Key Contributions
Summary of Contributions
- Designed and implemented the full application across Spring Boot, React, PostgreSQL, and Docker.
- Built QR/barcode identification workflows for retrieving physical record/item information.
- Modeled item lifecycle and movement states including storage, checkout, return, transfer, disposal, and missing states.
- Added responsibility tracking by recording who handled an item and where it was moved.
- Created a functional dashboard showing overall records and key storage/status counts.
- Documented backend APIs with Swagger.
Outcomes
Qualitative Outcomes
- Converted a manual paper-record concept into a working digital workflow.
- Centralized item, location, and status information within one application.
- Enabled QR and barcode-based lookup of physical records.
- Made item movement and responsible-user actions recordable and traceable.
- Modeled the full lifecycle of stored, checked-out, transferred, returned, disposed, and missing records.
- Demonstrated a complete Java/Spring Boot application following Java-focused training.
- Integrated backend, frontend, relational database, API documentation, and containerization into one owned system.
Training Impact
From Preparation to Full System Implementation
The immersion provided a practical environment to apply Java training beyond isolated exercises by designing and owning a complete full-stack system.
Related Evidence