Lab 5: MVP Implementation & Planning Report
The primary goal of our MVP is to deliver a fully functional and testable version of the Healthy Eating Hub, focusing on the essential features that demonstrate the platform’s core value to users.
The objectives are as follows:
- Enable users to create, manage, and share recipes, including accurate nutritional and cost information.
- Implement real-time pricing integration using the Market API to dynamically calculate recipe and ingredient costs.
- Provide meal planning with budgeting features, allowing users to set and monitor spending limits.
- Establish a moderation and reporting system for community content, including user reports, warnings, and bans.
- Support secure user management, including signup, login, password reset, and email verification.
- Implement certificate verification and profession tagging for verified nutrition professionals.
- Develop role-based access control to distinguish between admins, professionals, and standard users.
- Create a feedback and contribution tracking system, including badges, helped counts, and visible user impact metrics.
1.1.2.2 — Micronutrient display in recipe UI
1.1.5 — Real-time pricing (Market API integration)
1.2.10 — Certificate upload and verification
1.2.11 — Report users functionality
1.2.12 — Visibility of warnings and bans
1.2.13–1.2.16 — Contribution metrics (helped count, badges)
1.3.4 — Ingredient price linkage to API
1.3.6 — Filter recipes by cost
1.4.8–1.4.12 — Reporting system and moderation actions
1.4.13 — Limit post frequency
1.4.14 — User acknowledgment before posting
1.4.15 — Anonymous posting
1.5.1 — Budget selection and cost tracking for meal planning
1.7.5 — Budget selection (UI and logic incomplete)
1.7.5 — Password reset via email
1.7.6 — Email verification on signup
1.7.4 — Change password
1.8.2 — Role definitions (granularity and permissions)
1.8.3 — Admin privilege hierarchy
1.8.4 — Food item submission review
1.8.5 — Profession tag and certificate verification
1.8.7 — Report details (reason, reporter, timestamp)
1.8.8 — Moderation actions (remove, warn, ban)
1.8.9 — Moderation history tracking
1.8.10–1.8.16 — Advanced moderation (automation, notifications, appeals)
These objectives focus on the minimum functionality required to validate the core product concept—a collaborative platform connecting users, nutrition experts, and meal planners through transparent nutritional and cost data.
- Recipe creation, pricing, and meal planning represent the core user workflow, directly tied to the app’s main purpose.
- Authentication, verification, and moderation features are foundational for user trust and platform safety, especially in a health-related context.
- The budgeting and pricing tools are critical for testing economic usability—a key differentiator from other recipe-sharing platforms.
- Role and certificate management features allow us to validate expert–user interaction early, confirming that the platform can scale to verified professionals later.
By focusing on these areas, the MVP ensures that we test the product’s value, technical feasibility, and user adoption potential before moving to advanced functionalities such as automation, analytics, or gamified engagement.
The selected objectives align directly with the project’s core value proposition: empowering users to make informed, affordable, and healthy food choices with verified professional guidance.
- They ensure we cover all essential user stories — from account creation to recipe publication and moderation.
- They allow end-to-end validation of data flow across the backend (API, database) and frontend (React UI).
- They emphasize testable and measurable outcomes, such as cost calculation accuracy, report functionality, and user authentication success rate.
- They set a clear baseline for iterative improvements in future milestones, such as automation, recommendation systems, and community analytics.
These goals collectively represent the minimum scope required to demonstrate that the system is both technically viable and valuable to end users.
The critical points for the MVP were identified by focusing on features that most directly affect user trust, usability, and the platform’s core value proposition. These systems must work reliably from day one, as they shape first impressions and determine the platform’s long-term usefulness.
-
Recipe Cost Pipeline & Budget Features
This feature was prioritized because affordability and budget-based planning are central to the platform’s promise. Users come here to plan and cook within their means, so accurate cost calculations are essential for the app to deliver real value. -
Moderation and Reporting System
Community-driven content introduces the risk of misinformation and low-quality submissions. A robust moderation and reporting system was identified as critical to protect both users and the platform’s reputation.
Without it, unreliable user-generated content could quickly erode trust and diminish the app’s credibility. Prioritizing this early allows us to establish moderation workflows and safety norms from the start. -
Private Food Items
This feature supports personalization and flexibility. Many early users will want to experiment with personal or regional ingredients not yet available in the shared database.
Allowing users to create and manage private food items enables them to customize the experience, test experimental entries safely, and gradually contribute high-quality public data later on. -
Allergen Tags and Auto-Filter Preferences
Safety and accessibility were key factors in identifying this feature as core to the MVP. For users with dietary, religious, or allergen restrictions, filtering out unsuitable content is not optional — it’s essential.
Implementing this early ensures inclusivity and allows all users to confidently interact with the platform from the beginning. -
Reliability of Price and Nutrition Calculations
Transparent and verifiable data are critical for user trust. Users must be able to understand and verify how cost or nutrition values are calculated.
This transparency underpins confidence in the platform’s recommendations and ensures consistency across recipes and ingredients.
Before any development began, we created a set of well-defined issues that cover all core requirements and milestones in our GitHub project’s roadmap. Each issue represents a concrete, trackable task tied to a specific milestone — including the MVP — and is assigned to relevant team members.
We use the Status Board in GitHub Projects to monitor issue progress throughout development. Issues are organized into workflow columns (To Do, In Progress, In Review, Done), giving the team a transparent, real-time view of ongoing work and workload distribution.
A recurring challenge we faced was that some issues occasionally became stuck in the Review phase when reviewers forgot to follow up. To solve this, we designated a team member responsible for active issue monitoring.
This person checks the Status Board every two days to ensure forward movement, follows up with responsible contributors when needed, and provides short summaries of issue activity.
This process keeps the team aware of overall momentum and helps identify potential bottlenecks early.
Our development workflow emphasizes clear communication, consistent collaboration, and smooth integration across subteams.
- Subteams by domain: Mobile, Backend, and Frontend groups hold short planning meetings to align goals, divide responsibilities, and resolve technical dependencies.
- General meetings: Regular team-wide syncs are used to coordinate across subteams, discuss blockers, and ensure consistent progress toward milestones.
- Async daily updates: Members post brief updates in our group chat summarizing completed tasks, next steps, and any blockers.
- Pair programming and code reviews: Especially used for complex or cross-functional modules (e.g., Market, Moderation) to share knowledge and ensure code quality.
Our codebase is managed using GitHub Projects, combining a roadmap-driven, issue-based approach.
Each milestone is divided into actionable issues tracked through the Status Board, ensuring clear accountability and visibility for all contributors.
We follow a branch-based development model:
-
mainholds stable, production-ready code. - Feature branches are created from
mainusing a consistent naming convention:-
feat/<feature-name>for new features -
fix/<issue-name>for bug fixes
-
- Pull requests trigger team discussions, automated checks, and manual testing before merging into
develop.
This process ensures that integration is smooth, reviewed, and well-documented. Combined with consistent team communication and testing practices, it provides a strong foundation for steady, reliable progress.
Progress is continuously monitored through GitHub Milestones and Project Board analytics.
We regularly review the ratio of completed issues versus total issues to evaluate milestone completion and identify areas needing extra focus.
A designated progress tracker — Nuri — is responsible for reviewing the Status Board every two days, summarizing completed, ongoing, and pending tasks.
These summaries are shared with the team during general meetings and async updates, ensuring everyone remains aligned with current priorities and deadlines.
This structured tracking approach ensures accountability, supports data-driven progress evaluation, and helps the team stay on schedule toward the MVP and future releases.
During the previous milestone, the most important lesson we learned was the importance of clear team communication and early alignment on task responsibilities. In the initial phase, some minor delays occurred due to overlapping efforts and misunderstandings about individual deliverables.
We also realized that progress tracking was not sufficient, which caused some tasks to be delayed or unnoticed until later stages.
Another major lesson came from our demo, where we encountered unexpected bugs that had not been caught earlier. This highlighted weaknesses in our testing process and the need for more rigorous test validation before merging PRs.
Lastly, we learned the importance of planning database structures, API endpoints, and UI/UX designs earlier to prevent inconsistencies between frontend and backend components.
To address these issues, we took several actions in the current milestone:
- Assigned Nuri as the progress tracker, responsible for monitoring issues, ensuring timely updates, and tracking milestone completion.
- Strengthened our testing strategy by increasing the number of tests, improving test documentation, and requiring that no pull requests (PRs) are merged without adequate test validation.
- Finalized database schemas and API endpoints early to ensure smooth integration between frontend and backend.
- Began designing wireframes and user flows earlier, supported by short, weekly design review meetings to verify functionality and consistency.
Based on these lessons, we made the following process changes to enhance our workflow:
- Established clear task ownership and deadlines for each team member.
- Implemented structured weekly meetings to review progress and address blockers.
- Improved communication and coordination between team members using tools like Trello and Notion.
- Introduced dedicated issue tracking and progress monitoring led by Nuri.
- Enhanced our testing and validation practices to ensure higher-quality, more stable releases.
- Finalized architectural and design decisions earlier to reduce rework and improve efficiency.
These improvements have already resulted in better coordination, more reliable progress tracking, and higher development quality in the current milestone.
We have 58 total unit tests with the following status:
- Passing: 38 tests (65.5%)
- Failing: 10 tests (17.2%)
- Skipped: 10 tests (17.2%)
Coverage:
- Overall Codebase: 43% (12 out of 28 testable files)
- Components: 55% (6 out of 11 components)
- Pages: 31% (5 out of 16 pages)
| Category | Files Tested | Total Files | Coverage % | Test Count |
|---|---|---|---|---|
| Components | 6 | 11 | 55% | 18 tests |
| Pages | 5 | 16 | 31% | 38 tests |
| Core (App) | 1 | 1 | 100% | 2 tests |
| Total | 12 | 28 | 43% | 58 tests |
Tested Areas:
- Authentication (Login, Signup) - 15 tests
- Navigation & Layout (Navbar, Footer, MainLayout) - 9 tests
- Access Control (ProtectedRoute) - 4 tests
- UI Components (Logo, ThemeToggle) - 5 tests
- Home Page - 4 tests
Coverage Gaps:
- Meal Planning (0 tests)
- Food Management (FoodDetail, ProposeNewFood) - 0 tests
- Forum Features (PostDetail, CreatePost) - 7 tests (all skipped)
- User Profiles - 0 tests
Real Issues Our Tests Catch:
- Authentication failures and invalid credentials
- Weak password acceptance and validation bypasses
- Unauthorized access to protected pages
- Form validation errors (empty fields, email format, password requirements)
- UI/UX issues (missing content, broken layouts, incorrect navigation)
Real Issues We Cannot Catch (Due to Coverage Gaps):
- Meal Planning: Meal plans not saving, incorrect calorie calculations, broken food selection
- Food Management: Detail pages not loading, failed form submissions, incorrect nutritional data
- Forum: Posts not loading, broken like/comment functionality, search/filter issues
- User Profiles: Profile data not loading, failed profile edits, broken image uploads
We have 148 total unit tests distributed across all backend apps.
Coverage:
- Overall App Coverage: 80% (4 out of 5 Django apps have tests)
- Endpoint Coverage: Approximately 75% of API endpoints are tested
| App | Test Files | Total Files | Coverage % | Test Count |
|---|---|---|---|---|
| accounts | 6 | 6 | 100% | 70 tests |
| forum | 5 | 5 | 100% | 23 tests |
| foods | 1 | 1 | 100% | 47 tests |
| api | 1 | 1 | 100% | 8 tests |
| meal_planner | 0 | 1 | 0% | 0 tests |
| Total | 13 | 14 | 80% | 148 tests |
Tested Areas:
- Authentication & Authorization (Login, Signup, Token Management) - 11 tests
- User Profile Management (Profile, Contact Info, Images, Certificates) - 29 tests
- Password Management - 4 tests
- Logout - 4 tests
- Allergens & Tags Management - 24 tests
- Forum Posts (CRUD operations) - 4 tests
- Comments - 4 tests
- Likes - 4 tests
- Recipes - 7 tests
- Forum Tags & Filtering - 4 tests
- Food Catalog (Search, Filter, Category) - 9 tests
- Food API Integration (FatSecret, Open Food Facts, MealDB) - 15 tests
- Food Proposals - 18 tests
- Translation Service - 8 tests
Coverage Gaps:
- Meal Planner (0 tests)
- Some edge cases in existing features
- Some tests are failing mainly because of the database migrations
Real Issues Our Tests Catch:
- Authentication failures (invalid credentials, missing tokens, unauthorized access)
- Authorization violations (users modifying others' content)
- Data validation errors (missing required fields, invalid formats, constraint violations)
- API integration failures (external service errors, malformed responses, timeouts)
- Business logic errors (nutrition calculations, allergen assignments)
- File upload issues (invalid file types, size limits, missing files)
- Database constraints (unique violations, foreign key errors)
Real Issues We Cannot Catch (Due to Coverage Gaps):
- Meal Planning: Meal plan creation/update failures, nutrition calculation bugs, concurrent meal plan activation issues
- Advanced search/filter edge cases in partially tested features
- Complex multi-user scenarios and race conditions
- Performance issues under load
We currently have 9 automated test files containing approximately 130 individual test cases, organized into component, screen, service, and context tests.
All tests are executed with Jest and React Native Testing Library, following a structured convention similar to the web frontend.
- Passing: 113 tests (87%)
- Failing: 9 tests (7%) — mostly related to incomplete UI mocks and asynchronous behavior
- Skipped: 8 tests (6%) — intentionally deferred due to complex UI rendering (e.g., secure text entry toggle, clear button in TextInput)
- Overall Codebase: 42% (measured by Jest coverage report)
- Core Logic (Services & Context): 65%
- Components: 48%
- Screens: 28%
| Category | Files Tested | Total Files | Coverage % | Test Count |
|---|---|---|---|---|
| Components | 2 | 4 | 48% | 25 tests |
| Screens | 2 | 7 | 28% | 20 tests |
| Services | 4 | 6 | 67% | 45 tests |
| Contexts & Hooks | 1 | 2 | 63% | 40 tests |
| Total | 9 | 19 | 42% | 130 tests |
- Authentication (login, logout, token handling) – 40 tests
- API services (forum, auth, client integration) – 45 tests
- UI components (Button, TextInput) – 25 tests
- Screens (HomeScreen, LoginScreen) – 20 tests
- Hooks & form utilities (useForm, context state) – 10 tests
- Navigation stack and deep link handling
- Recipe creation and detail flows
- Profile screen interactions and image uploads
- Mobile meal planner (planned for next milestone)
- Authentication failures (invalid credentials, token expiration, async state issues)
- Incorrect API parameter handling and request errors
- Inconsistent context state after logout or failed network calls
- UI regressions such as disabled button interactions, error message rendering, and helper text display
- API-level data mismatches between mobile and backend responses
- Navigation routing and tab switching behavior in multi-screen flows
- Form validation and error feedback for recipe creation
- Media upload handling (profile and certificate images)
- Complex interactions involving chained API calls (forum post + recipe tag linking)
- Frameworks: Jest, React Native Testing Library
- Mocking: Axios, AsyncStorage, Expo icons, React Navigation, and native components
- Configuration:
jest.config.jsandjest.setup.jsfor consistent mock setup - Execution:
npm test -- --coverageThe environment is fully isolated and supports CI/CD integration for future automated test runs.
- Users can search and view food items in the catalog with MarketFiyati API prices from various markets
- Users can create private food items visible only in their catalog
- Private food items can be used in recipes and are marked with a private tag for other users
- Users can view and manage their personal recipes from their profile
- Users can edit their personal information (name, bio, avatar)
- Users can report other users through a simple UI
- Profile displays badges for recipe milestones (10/50/100 posted) and engagement (10/50/100 likes received)
- Badges are visible to all users visiting the profile
- Recipe total costs are automatically calculated using price information from food items
- Users can create meal plans with total cost calculated from market prices
- Users can set an optional budget and receive warnings when meal plan cost exceeds budget
- Moderators can review reported posts and users with full context (reason, reporter, timestamp)
- Moderators can take actions: remove content, warn, suspend, or ban users with logged decisions
- Users can submit appeals for flagged/removed content or account actions
- Moderators can review and approve/reject appeals with user notifications
- Moderators can review and verify profession certificates
- Content/Data Administrators can review and approve/reject food item submissions
- Role-based moderation dashboard displays pending tasks with priorities
- API Integration Testing: Verify MarketFiyati API returns accurate price data
- Manual Testing: Create and verify private food items across multiple user accounts
- User Testing: 3-5 users complete core workflows
- Stakeholder Demo: Walkthrough of all features for approval
- Manual Testing: Execute test scenarios and verify expected outcomes
- Calculation Testing: Verify recipe cost calculations with sample data
- Integration Testing: Test cost updates when food prices change
- Functional Testing: Create meal plans and verify cost calculations
- Budget Testing: Test budget warning triggers with various scenarios
- Role-Based Testing: Test each moderator role with appropriate permissions
- Workflow Testing: Execute complete moderation workflows from report to resolution
- Notification Testing: Verify all user notifications are sent correctly
- View Market Prices: User searches "tomato," selects it, and sees prices from 3+ markets via MarketFiyati API
- Create Private Food Item: User clicks "Add new food item," enters details, selects "add as private," item appears only in their catalog
- Use Private Item in Recipe: User creates recipe with their private food item, other users see it marked with "private" tag
- Manage Recipes: User views their recipe list in profile and can edit/delete recipes
- Edit Profile: User updates bio and profile picture, changes persist after refresh
- Report User: User selects another user, clicks report, chooses reason, submits successfully
- View Badges: User with 15 recipes and 60 likes sees "10 Recipes" and "50 Likes" badges
- Badge Award: User posting their 10th recipe automatically receives first badge
- Public Badges: Other users can see earned badges when visiting the profile
- Recipe Cost Calculation: User views recipe with 5 ingredients, total cost is displayed based on current food prices
- Cost Update: Food item price changes, recipe total cost updates automatically
- Create Meal Plan: User adds 3 recipes to meal planner, total cost is calculated and displayed
- Budget Warning: User sets $50 budget, adds recipes totaling $65, receives warning message "Meal plan exceeds budget by $15"
- Report and Review Post: User reports a post, moderator sees it in dashboard with reason/timestamp, decides to remove post and warn user, decision is logged and user receives notification
- Report and Review User: User reports another user's profile, moderator reviews behavior history, suspends user for 7 days with reason, user is notified
- Content Appeal: User's post is removed, user submits appeal, moderator reviews and approves appeal, content is restored and user is notified
- Certificate Verification: User submits professional certificate, moderator reviews and verifies profession tag, user receives confirmation notification
- Food Submission Review: User submits new food item "quinoa," Content Administrator reviews, approves for catalog, submitter is notified
- View Moderation Dashboard: Community Moderator logs in and sees pending reports (3), appeals (1), certificate requests (2), and food submissions (1) with priority indicators
Conclude with a short summary of your implementation readiness, how lessons have improved your approach, and how you plan to ensure MVP delivery on time.
