Milestone 2: Requirements Engineering and MVP Development

Overview¶

In Milestone 1, you built the foundation for your project — forming your team, defining your vision, setting up tools, and capturing your first high-level feature list. Now it is time to move from vision to definition and from definition to a working first version. In the software industry, this stage is where ideas are transformed into precise requirements, visualized through models, and proven through an early but functional product.

With your project foundation set, it’s time to define what your To-Do List app truly needs—like turning vague ideas into precise specs, just as engineering teams do before building. In this milestone, you’ll refine your feature list into structured user stories, create a Software Requirements Specification (SRS), model key elements with UML diagrams, select a Minimum Viable Product (MVP), and implement a simple Command-Line Interface (CLI) version in Python (e.g., basic task addition, listing, and completion). This draws on requirements engineering and modeling concepts, focusing on clarity and feasibility without advanced design or automated testing—validate manually to ensure it works as intended.

By the end of this milestone, you will have documented requirements, visual models, and a functional CLI-based MVP — all versioned through GitHub releases for professional tracking. This deliverable will serve as a validated and documented starting point for expanding your application in later milestones, ensuring each new feature builds on a reliable and well-understood base.

Learning Objectives¶

Upon successful completion of this milestone, you will be able to:

• Elicit and document requirements using user stories, use cases, and a structured SRS.

• Model software systems with UML use case, class diagrams.

• Define an MVP by selecting core features and outlining validation approaches.

• Implement a basic CLI application in Python, applying requirements and models.

• Prioritize requirements using techniques like planning poker for consensus.

• Manually validate the MVP to confirm it meets initial requirements.

Tasks and Instructions¶

1. Team Meeting Execution¶

Align your team on requirements and MVP through focused discussions.

• Hold team meetings with agendas covering backlog refinement, SRS drafting, UML creation, and MVP implementation.

• Assign action items with owners and deadlines.

• Save meeting minutes in a structured format in the repository. e.g.:/task_manager_app/docs/meeting_minutes/milestone_2/

2. Refine Product Backlog¶

Transform your initial feature list into actionable, user-focused items.

• Convert features to user stories in the format:

  As a [user], I want [feature] so that [benefit].

• Include functional and non-functional requirements; prioritize using planning poker for estimation and consensus.

• Update /task_manager_app/docs/backlog/ and import/refine issues in GitHub Projects with priorities and assignees.

3. Create SRS¶

Develop a formal Software Requirements Specification (SRS) to document your system’s intended functionality and constraints.

• Use the SRS template as your structural guide. Modify or omit sections only if clearly justified.

• Complete the SRS based on what you have developed so far in Milestone 1 (vision, backlog, roles) and Current Milestone (user stories, UML diagrams, MVP design).

• Your initial SRS should include:

  • Introduction & Purpose

  • Overall Description (system context, user characteristics, assumptions)

  • Functional Requirements (mapped from user stories and backlog)

  • Non-Functional Requirements (e.g., usability, performance, platform constraints)

  • Use Cases or User Interactions (linked to UML diagrams)

  • Assumptions and Constraints

• Reference related artifacts in your documentation (e.g., link specific user stories, diagram files, or backlog items).

• As your project evolves, you are expected to continuously update this SRS in future milestones to reflect changes in features, scope, and design decisions.

• Save the document as:

  • /task_manager_app/docs/srs.md

Tips: Treat the SRS as a dynamic contract between your team and your users. Keep it aligned with implementation decisions, feedback, and design iterations throughout the course.

4. UML Modeling¶

Visualize your system’s interactions and structure.

• Create UML use case diagrams.

• Develop class diagrams for the CLI MVP.

• Use tools like lucidchart; export diagrams as images or embeddable files.

• Save to /task_manager_app/docs/uml/.

5. Define and Implement MVP¶

Focus on core functionality for a testable prototype.

• Select MVP features (e.g., add task, list tasks, mark as complete) based on priorities; outline validation (manual testing scenarios).

• Implement in Python CLI:

  • Implement in /task_manager_app/src/ with basic functions.

  • Example: Command-line menu for operations; persist data in a text file/json file if needed.

• Manually validate: Run the app, document sample inputs/outputs in /task_manager_app/docs/mvp_validation.md.

6. Github project Board¶

• Update GitHub Project board with new user stories, SRS tasks, UML tasks, and MVP implementation tasks; link to commits.

7. Individual Reflections¶

• Submit a .md file via Canvas with links and reflection answers (see Submission Checklist).

8. GitHub Releases¶

• Progress Check (After 1 week):

  • Create a minor release: v1.1

  • Tag example: milestone2-progress-v1.1

  • Include drafts of SRS, backlog, UML, and initial code.

  • Submit the release URL via Canvas

• Final Submission (After 2 weeks):

  • Create a major release: v2.0

  • Tag example: milestone2

  • Include final documents, code, and changelog summarizing additions/edits since v1.1.

  • Submit (re-submit) the final release URL via Canvas

Submission Checklist¶

Submit via Canvas:¶

A .md file containing:¶

• GitHub release link (e.g., https://github.com/user_name/project_name/releases/tag/v2.0)

• GitHub Project board link (e.g., https://github.com/user_name/project_name/projects/1)

• Reflection answers:

  • Your Contribution to the project (50–100 words): Describe your role (e.g., UML modeling).

  • Most important thing you learned in this milestone (40–60 words): Share a key skill, concept, or tool you now understand better.

  • How does the project vision align with your software engineering goals? (50–100 words): Connect to personal aspirations.

  • Reflection on this milestone (50 words): Reflect on your experience and learning during this milestone.

Repository Documents¶

• Refined Product Backlog (suggested: /task_manager_app/docs/backlog/)

• SRS (suggested: /task_manager_app/docs/srs.md)

• UML Diagrams (suggested: /task_manager_app/docs/uml/)

• MVP Validation (suggested: /task_manager_app/docs/mvp_validation.md)

• Meeting Minutes (suggested: /task_manager_app/docs/meeting_minutes/milestone_2/)

GitHub Releases¶

• Progress Check

• Final Submission

GitHub Project Board¶

• Updated with new user stories, SRS tasks, UML tasks, and MVP implementation tasks; linked to commits.

Evaluation Rubric (100 Points)¶

Penalties: 20% for missing progress check after first week.

Resources¶

Textbook¶

• Chapter 3: Requirements

• Chapter 4: Models

Beginner Friendly Resources¶

• User Stories Explained

• UML Basics

• Building a CLI in Python

• Working with JSON in Python

Tutorials¶

• Writing Effective User Stories

• draw.io for UML

• Planning Poker Guide

• SRS Template

• Reading and Writing Files in Python

CLI Enhancement Libraries (Python)¶

Rich¶

A modern Python library for creating visually appealing command-line interfaces, supporting features such as tables, panels, markdown rendering, and syntax highlighting.

• Documentation: rich.readthedocs.io

• Tutorial: Real Python – Using the Rich Package Suggested Use: Enhance the CLI experience with colored output, formatted tables for task lists, and readable sections for prompts or validation results.

Typer¶

A lightweight library for building intuitive command-line interfaces using Python type hints. Built on top of Click, Typer simplifies CLI app development with automatic help generation and command parsing.

• Documentation: typer.tiangolo.com

• Tutorial: Quickstart Guide Suggested Use: Create structured CLI commands like add, list, or complete for task operations with clear argument handling and auto-generated help menus.

cmd2¶

An enhanced wrapper around Python’s built-in cmd module that adds advanced features like tab completion, command history, and argument parsing.

• Documentation: cmd2.readthedocs.io

• Tutorial: Getting Started Suggested Use: Develop a shell-like interface with interactive commands and command chaining for task management.

All Project Milestones¶

1. Milestone 1

2. 📌 Milestone 2

3. Milestone 3

4. Milestone 4

5. Milestone 5

6. Presentation

7. Final Submission