FINAL PROJECT GUIDELINES

In this 5-week team-based final project, your group will act as a software development team building a functional application. The application must incorporate a user interface (web or desktop), persistent storage (database), and core functionality such as user registration, login, CRUD operations, data search/display, and other more specific system features.

You will use Agile methodologies to manage your development process. The project will emphasize real-world software practices including:

  • Requirement elicitation.
  • User stories and scenarios.
  • Incremental delivery using SCRUM (with backlogs, sprints, Kanban boards).
  • Testing (unit, integration).
  • Communication and reflection via retrospectives.

Project Goals

The goals of the final project are in line with the class goals of 1) Broaden your knowledge and understanding of various software engineering/software development topics 2) Enhance your software development skills — programming & teamwork — through hands-on experience with existing and new projects and 3) Develop and apply professional life-long learning skills, including learning new computing skills on your own or in a group using professional resources.

Specific goals are:

  • Apply software engineering concepts in a team environment.
  • Practice Agile and Extreme Programming (XP) principles.
  • Deliver working software iteratively with continuous feedback.
  • Collaborate and communicate effectively using tools like Git and Jira.

Learning Outcomes

By completing this project, students will be able to:

  • Plan and manage a software project using Agile.
  • Elicit and document software requirements.
  • Write user stories, acceptance criteria, and usage scenarios.
  • Apply SCRUM to organize work into sprints and track progress.
  • Use version control (Git) effectively within a team.
  • Design and implement a system with persistent data storage and user authentication.
  • Test and debug incrementally (unit and integration testing).
  • Deliver functional prototypes and reflect on the development process.

Final Project Features and Requirements

For your final project, you and your team will come up with your own idea of what kind of software you will develop. The only requirement is that your team use and integrate the following technologies and features:

  • Your project needs to integrate a database for CRUD operations.
  • You need to use Agile methodologies to develop the software.
  • Your system needs a graphical user interface (UI) to facilitate navigation of your application.
  • Your system needs the following (required) features:
    • Search capabilities.
    • User registration and login capabilities.
    • Data display capabilities (presenting information to the user).
    • Other CRUD features that you identify (which are specific to your project idea) to facilitates persistent storage (create, read, update or delete data).

Some technologies you can use (which will probably require you and your team to learn or refresh programming skills):

  • Frontend or UI: What will be needed by Users to interact with the application. HTML/CSS/JS or a framework of your choice like JSP or Java Server Pages, which allows to develop a frontend by embedding Java code in HTML pages. Framenworks exist to allow you to develop application (specially UI) with Python.
  • Backend logic: What the system will use to facilitate interactions between the UI (and users) and the database. Java or Python are the recommended programming languages to work with. If your team feels more confortable developing with other languages, feel free to use them. The choice of Java/Python is based on the initial survey of languages you (as a class) know.
  • Persistent data storage: Where data will be permanently stored. PostgreSQL, MySQL, or SQLite are databases (or DBMS, Database Management Systems) you can install in your computer. You can also use online databases that are free.
  • Version control: to keep the team up-to-date with development. Git and GitHub are recommended. This repository can be use in your CV or resume when you are applying for internships or a job, so make sure you and your team keep it organized!
  • Agile project management tool like Jira (strongly recommended).
  • Unit testing framework: To test your code you can use JUnit for Java, pytest/unittest for Python.

Recommended Timeline

The following are recommended stages for the final project. I've organized them by week (starting in week 6), but depending on your team's work, you might mix/merge/match these recommendations with your own.

Week 1: Project Planning & Requirements Elicitation

Focus: Understand the project vision, users, and system needs.

To Do

  • Meet with the team and define a shared project idea (based on provided tech + core features).
  • Identify system users, stakeholders, and goals.
  • Perform mock requirement elicitation.
  • Write functional and non-functional requirements.
  • Develop user personas and usage scenarios.
  • Start initial user stories and acceptance criteria.

Deliverables

  • Project Idea Proposal:
    • Clearly describe the problem the application addresses.
    • Identify key users or audience.
    • Outline of system goals and a few potential features.
  • Requirements Summary Document:
    • Lists some meaningful functional and non-functional requirements, organized and written clearly.
    • Show evidence of early requirement elicitation.
  • User Stories and Usage Scenarios draft:
    • Include at least 3-5 user stories (these are preliminary, they might change) that allow you to start implementing them during Sprint #1.
    • At least 1 usage scenario that walks through system interaction (based on one of your stories).
  • Initial Git repo (send an invitation to collaborate).
  • Team setup: define team member roles (e.g., Scrum Master, lead dev, tester), reflecting a plan for shared responsibilities.

Week 2: Design, Sprint Planning and Setup

Focus: Design system components and set up team tools.

To Do

  • Plan Sprint #1 and create Product Backlog (using Jira).
  • Design database schema and basic UI wireframes.
  • Define initial system architecture and tech stack.
  • Assign team roles (Scrum Master, developers, testers, UI designers, etc.).
  • Start Sprint #1 development

Deliverables

  • Sprint #1 Backlog and Plan (via Jira or screenshots).
  • System Architecture Diagram (via Use Case diagrams).
  • Database ER Diagram or Schema Design.
  • Wireframes for main UIs (you can use Figma or any other software).

Week 3: Developing Sprint #1 - Core Features

Focus: Build and test basic functionality (like user login, registration, UI + database integration, and so on).

To Do

  • Continue developing core features in Sprint #1.
  • Write tests as you build (like unit tests, using a TDD approach).
  • Update stories, Kanban board, and backlog as needed.
  • Perform your "Daily" standups or check-in meetings (for the most part you'll have 10 minutes in each class to have these meetings).
  • Conduct Sprint #1 Retrospective once you conclude all the work needed.
  • Start planning Sprint #2

Deliverables

  • Working prototype of: login/registration or basic navigation or any core feature you were able to implement.
  • Completed and updated user stories.
  • Sprint #1 Review & Reflection Summary.
  • Some of your test cases.

Week 4: Developing Sprint #2 - Other Features

Focus: Expand functionality with search, display, and full data management features.

To Do

  • Plan and execute Sprint #2 (search, data display, CRUD features).
  • Write tests as you build (like unit tests, using a TDD approach).
  • Fix bugs and refactor code as needed.
  • Track progress using Agile board and burndown charts.
  • Prepare for a final (substantial) demo in next sprint.

Deliverables

  • Prepare a reflection for your Sprint #2 Retrospective:
    • Meet with your team and following this link on How to run your first retrospective, prepapre a document with your experience as a group developing Sprint #2. Please include some screenshots of your Jira/Taiga/GitHub Projects boards, any UI you've developed so far and any other screenshot you deem necessary.

Week 5: Final Sprint and Project Presentation

Focus: Polish UI, test system, and prepare final demo.

To Do

  • Complete final features and fix bugs.
  • Conduct final round of testing (unit + user-based).
  • Polish UI/UX and deploy local or hosted versions.
  • Prepare demo presentation and submit link to your final repository.
  • Final Retrospective: team process, challenges, and lessons.

Deliverables

  • Final Project presentation.
  • Fully working codebase in Git (with README + how-to-run instructions).
  • OPTIONAL: Final SRS Document (including summary, design, tests, roles, reflection).


Presentation Guidelines

Groups: You will present with your teammates (5 students each)

Time: Your group will have a total of 20 minutes to present your final project's results. You should divide this time to present your findings. This time should be equally divided between your group members (or as equally as it can be divided). After that, your classmates will have 5 minutes for Q&A.

Slides and Presentation: This is roughly an ideal structure for your presentation slides:

  • Title and Outline: Be sure to include all group members names on the title slide including the title of your project. You should have an outline slide for your classmates to have a road map of your talk.
  • Introduction: Start out with a big picture of the work done by your group: what, why, how. First motivate the work you've done (why is it interesting/important). Offer a high-level description of the project (what can the client do with it, for example).
  • Details of your Project: Describe the core technology you use to develop your project in detail (remembering the time constarint of 20 mins per group). You can give examples (Use Case diagrams, ERDs, Sequence diagrams, etc), and/or a demo of your code. Make sure you understand what you are explaining to the class.
  • Conclusion and Reflection: Discuss - what did you learn from your project as a group? What was difficult? Are there any interesting problems or questions that resulted from your work?


Presentation Evaluation

Your presentation will be evaluated by your classmates as follows (10 pts. total):

  • Preparedness, Participation, and Group Dynamics: Presenters showed a good understanding of their project, participated equally, and helped each other as needed. 2.0 pts
  • Presentation Content: The presentation was a concise summary of the project with comprehensive coverage of information. 2.0 pts
  • Presentation Skills: The audience was engaged, and presenters held the audience's attention. Appropriate speaking volume and body language. 2.0 pts
  • Visual Appeal: No errors in spelling, grammar and punctuation. Information is clear and concise on each slide. Visually appealing/engaging. 2.0 pts
  • Contribution to Class: Do you consider that this group's project made an effective contribution to your knowledge about Software Development techniques/technologies? 2.0 pts

A separate evaluation will be performed by me, using the following rubrics (8 pts. total):

  • Presentation: Does the presentation adequately cover the imporatnt aspects of the project: objective or problem to be solved, the techniques and technologies used, one (or more) interesting challenge, comprehensive evaluation, and meaningful conclusions? 2.0 pts
  • Progress: Was substantial progress made on the project since our check-ins. 1.0 pt
  • Teamwork: The team worked well together to achieve objectives. Each member contributed in a valuable way to the project. The final presentation indicated a high level of mutual respect and collaboration. 2.0 pts
  • Contribution to Class: The project offered good information or approach about the Software Development process. The presentation also showed a strong effort was made in completing the development of the project, its integration and prototyping. 2.0 pts
  • Content and Creativity: The presentation was imaginative and effective in conveying the group's ideas to the audience. 1.0 pts