The Problem
The coursework goal was to build a Java/MySQL employee management system that connected software design artifacts with a working database-backed application. The team needed to cover employee record maintenance, search, reporting, salary updates, schema design, and test planning while keeping employee-like sample records and local database credentials out of public materials.
What We Built
The group built a Java console application connected to a MySQL database through JDBC and MySQL Connector/J. The system covered employee add, update, delete, search, list, salary-adjustment, and reporting flows backed by SQL scripts, UML diagrams, ER diagrams, programming tasks, and test cases.
Project Overview
This was a CSc3350 Software Development group project. Public copy describes team coursework output and uses sanitized, recreated visuals instead of raw source screenshots or employee-like records.
My Contribution
- Contributed as a Java/MySQL developer and software development team member.
- Worked with JDBC-driven application flows that connected console actions to a MySQL employee database.
- Helped align implementation evidence with design artifacts, SQL scripts, programming tasks, and test cases while excluding local credentials and employee-like data from the portfolio.
Database Workflow
Java console to MySQL workflow
The application presents employee-management actions, executes SQL through JDBC, and returns sanitized results or reports.
The diagram is recreated from inspected evidence and excludes local credentials, employee emails, sensitive identifiers, salary records, and raw employee-like rows.
Technical Decisions
Use JDBC and prepared SQL statements for employee-management actions.
- The project needed to demonstrate Java database connectivity while keeping add, update, delete, search, and salary-update operations close to the SQL they exercised.
- A console app is intentionally simple, so it does not include authentication, a GUI, or a separate service layer.
- The team could validate core database workflows and reports without adding framework complexity.
Model employee data with normalized tables and explicit relationship scripts.
- The design documents required database schema, ER diagrams, UML artifacts, and testable reporting queries.
- The schema and seed data were useful for coursework, but public portfolio content must generalize employee-like data and omit sensitive fields.
- The public case study explains employees, payroll, divisions, job titles, addresses, and key relationships without exposing raw rows.
How I Work
Engineering Challenge
- The original coursework materials contain local credentials and employee-like sample records.
- I inspected Java sources, SQL scripts, submitted design documents, programming tasks, and test cases to separate safe architecture claims from sensitive details.
- The case study uses recreated diagrams, generic table names, and group-project framing while omitting credentials, raw screenshots, employee emails, sensitive identifiers, and salary rows.
- The project communicates Java/MySQL fundamentals and software-development process without leaking private or sensitive-looking data.
Quality & Testing
Quality Evidence
Product engineering evidence
- Submitted test-case documentation covers valid and invalid update flows, valid and invalid search flows, and salary-update behavior for eligible and non-eligible ranges. No automated test totals are claimed.
- No public CI claim is made for the coursework app. The portfolio page is verified through this site's lint, typecheck, unit, build, verify, e2e, responsive, and accessibility checks.
- Evidence verifies Java, JDBC, MySQL Connector/J, SQL scripts, employee CRUD/search/list workflows, reporting joins, salary-range updates, UML diagrams, ER diagrams, programming tasks, and test cases.
Public page quality
- The public architecture diagram and cover are recreated SVG assets with descriptive metadata and no raw private screenshots.
- The case study uses the shared portfolio layout and was manually reviewed across mobile and desktop viewports.
- No database passwords, local credentials, local paths, employee emails, sensitive identifiers, salary records, raw rows, or private screenshots are bundled.
| Area | Evidence | Published detail |
|---|---|---|
| Application layer | Java source files | Console menu, JDBC, CRUD/search/list/report actions |
| Database design | SQL scripts and ER diagrams | Employees, payroll, divisions, job titles, addresses, and relationships |
| Planning and tests | Design document, programming tasks, test cases | Group coursework process and sanitized validation scenarios |
Results & Impact
The project demonstrates a complete coursework system around employee data management: Java console menus, MySQL connectivity, add/update/delete/search/list flows, range-based salary updates, reporting queries, normalized schema scripts, UML/ER documentation, programming tasks, and test-case planning.
What I Learned
This project made database-backed Java development concrete. It tied SQL schema design, JDBC connection handling, query execution, reporting, and test planning into one small system, while also making clear why credentials and employee-like data need a privacy pass before anything becomes public.