Mobile Application

Development
Apply Software Engineering to
Collect Requirements for a Mobile
Application
 What is a Mobile App?
• A mobile application (app) is software
designed to run on mobile devices, such as
smartphones and tablets, providing specific
functionalities or services.
• Think of it this way:
• Your phone is like a toolbox.
• Each app is a different tool inside that box—a
hammer (camera), a screwdriver (calculator),
a measuring tape (maps), etc.
Key Characteristics of Mobile App
• Designed for Small Screens: They have touch-friendly
interfaces with buttons and menus sized for fingers.
• Uses Device Features: They can use your phone's
hardware, like the camera, GPS, microphone,
and accelerometer (the thing that knows when you tilt
your phone).
• Specific Purpose: They are built to do a specific job,
whether it's for gaming, social media, banking, or
education.
• Image Suggestion: A collage of common app icons
(WhatsApp, Instagram, Google Maps, Spotify, Camera)
on a smartphone home screen.
 Online Access to Applications
• Online access refers to the ability to use
applications over the internet, often through web
browsers, allowing users to access features and
data remotely. This refers to how you get apps
onto your device and how they connect to the
internet.
• Application Stores (The "App Shops"):
These are the official platforms where you can
browse, download, and install apps.
• Google Play Store: For Android devices.
• Apple App Store: For iOS devices (iPhone & iPad).
Online-Only vs. Offline-Capable Apps
• Online Access Required: These apps need an
active internet connection to
work. Example: WhatsApp (to send/receive
messages), Uber (to book a ride), Netflix (to
stream videos).
• Offline Capable: These apps can perform their
core functions without the
internet. Example: A simple calculator, a notes
app, or a game like Subway Surfers.
 List Variety of Mobile Programming
Languages
• Just like humans use different languages
(English, Spanish, etc.), developers use
different programming languages to "talk" to
devices.
Platform Primary Languages

Kotlin (Modern,
Android recommended), Java (Traditional, still
widely used)

Swift (Modern,
iOS recommended), Objective-
C (Traditional, legacy)

Dart (used with

Cross-Platform Flutter), JavaScript (used with React
Native), C# (used with Xamarin)
 Variety of Mobile Programming
Languages
• Let's break down the pros and cons of each approach.
• a) Native Languages (Kotlin for Android, Swift for iOS)
• Pros:
– Best Performance: Very fast and smooth because they are built
specifically for one operating system.
– Full Feature Access: Can use all the phone's hardware and
software features directly.
– Great User Experience: Feel and look exactly like other apps on
that platform.
• Cons:
– Separate Codebases: You must write two completely separate
apps (one in Kotlin, one in Swift) to be on both Android and
iOS. This is more time and money.
 Cross-Platform Languages
(Dart/Flutter, JavaScript/React
Native)
• Pros:
– Single Codebase: Write the code once and deploy it
to both Android and iOS. This is faster and cheaper.
– Faster Development: Changes are visible quickly.
• Cons:
– Slightly Lower Performance: May not be as fast as a
perfectly tuned native app (but for most apps, the
difference is unnoticeable).
– Delayed Access to New Features: When Apple or
Google releases a new phone feature, cross-platform
tools need time to add support for it.
 Analyze Mobile App Requirements
Definition
• What is it? This is the "Planning Phase" where
you decide what your app will actually do
before you write a single line of code. It's like
creating a blueprint before building a house.
 Key Questions to Answer:
• What problem does it solve? (e.g., "Helps
students find shared taxi routes to college.")
• Who is it for? (Target Audience) (e.g., "Students
aged 18-25.")
• What are its core features? (e.g., User login,
route posting, map view, chat.)
• What platform will it be on? Android, iOS, or
both?
• What is the budget and timeline?
Analyze Different Mobile App Design
Options
• Design is about how the app looks (UI - User
Interface) and how it feels to use (UX - User
Experience).
• 1. Native Design:
• Follows the official Android Material
Design or Apple iOS Human Interface Guidelines.
• Pro: Users find it intuitive because it behaves like
every other app on their phone.
• Con: The app will look different on Android vs.
iOS.
 Custom Design:
• The app has a unique, branded look that is the
same on all platforms.
• Pro: Strong brand identity and a consistent
experience everywhere.
• Con: Users might need a moment to learn
your custom patterns.
 Hybrid Design:
• A mix of native and custom. For example,
using native navigation but with custom-styled
buttons and colors.
• This is the most common approach, balancing
familiarity with brand uniqueness.
 Develop a Mobile App (The Step-by-
Step Process)
• Here is a simplified version of the development
lifecycle.
• Step 1: Ideation & Planning (Define your
requirements, as discussed above).
• Step 2: Design (Create wireframes and mockups
of every screen).
• Step 3: Development (Write the code – the
"construction" phase).
• Front-End (Client-Side): What the user sees and interacts
with.
• Back-End (Server-Side): The brain behind the app—handles
data, user accounts, and logic on a remote server.
 Develop a Mobile App (The Step-by-
Step Process)
• Step 4: Testing (Rigorous checking for bugs,
crashes, and usability issues).
Step 5: Deployment (Publishing the app to the
Google Play Store and/or Apple App Store).
Step 6: Maintenance & Updates (Fixing new
bugs, adding new features, and keeping the
app compatible with new OS versions).
 Requirements Specifications
Document
• What is it? This is your app's blueprint. It's a
single document that describes everything the
app should do, who it's for, and how it should
work. It ensures everyone (developers,
designers, clients) is on the same page.
Key Sections for a Student Project:
• 1. Introduction & Goals
• App Name: StudyBuddy
• Purpose: "To help diploma students
collaboratively manage their assignment
deadlines and share notes in one place."
• Target Audience: *Diploma students aged 18-
25.*
 Functional Requirements (WHAT the
app will DO)
• This is a list of features. Be specific.
• User Authentication:
– Users can register for a new account using their email
and a password.
– Users can log in with their registered credentials.
– Users can log out.
• Dashboard:
– Displays an overview of upcoming assignments.
– Shows a quick summary of recent notes from shared
subjects.
Functional Requirements (WHAT the
app will DO)
• Assignments Module:
– Users can Add a new assignment (Title, Subject,
Due Date, Priority).
– Users can View a list of all assignments.
– Users can Mark an assignment as complete.
• Notes Module:
– Users can Create a new note (Title, Subject, Text
Content).
– Users can View a list of notes, filtered by subject.
Non-Functional Requirements (HOW
WELL the app will do it)
• Performance: The app should load any screen
in less than 2 seconds.
• Usability: The interface should be intuitive
enough for a new user to navigate without
instructions.
• Platform: The app will be developed for
Android first, using Kotlin.
 QUIZ
• What are the differences between Functional
and Non Functional Requiremenst?
 Design a User Interface (UI)
• What is it? UI is the visual part of the app—the
screens, buttons, text, and images that users interact
with.
Core Principles for Good UI:
• Clarity: Is everything easy to understand? Use clear
labels.
• Consistency: Use the same colors, fonts, and button
styles throughout the app.
• Simplicity: Don't clutter screens. Use plenty of white
space.
• Feedback: The app should respond to user actions.
(e.g., a button should look like it's been pressed).
 The Design Process:
• Sketch/Wireframe: Create a rough, black-and-
white layout of each screen. This focuses on
structure, not colors.
• ✏️ Image Suggestion: A hand-drawn sketch of
an app screen next to a digital wireframe made
with simple lines and boxes.
• Mockup: This is the high-fidelity, visual version of
the wireframe. It includes the final colors, fonts,
and images.
• 🎨 Image Suggestion: The final, colored visual of
the app's home screen.
 Create a Login Menu Screen
• Let's apply the UI principles to design a standard login
screen.
Essential Elements:
• Logo/App Name: Place this at the top.
• Input Fields:
– Email Field: With a little envelope icon on the left.
– Password Field: With a lock icon 🔒 on the left. It should have
an "eye" icon to toggle visibility.
• Action Buttons:
– Login Button: A prominent, colored button saying "LOG IN".
– Sign Up Link: Text that says "Don't have an account? Sign Up".
• Forgot Password?: A small text link below the password
field.
 UI/UX Considerations for the Login
Screen:
• Keyboard: The email field should automatically
trigger the email keyboard. The password field
should trigger the standard keyboard but hide the
characters as dots.
• Validation: If the user enters a wrong email
format, show a red error message like "Please
enter a valid email."
• Visual Hierarchy: The "Log In" button should be
the most prominent element on the screen after
the input fields.
 Create Required Icons for the Mobile
App Functions
• Icons are visual symbols that represent actions
and content. Good icons are simple,
recognizable, and consistent.
• Icon Set for Our StudyBuddy App Example:
Icon Set for Our StudyBuddy App
Example:
How to Create Icons (Tools & Tips):
• Keep it Simple: Avoid too much detail. Icons are small.
• Be Consistent: Use the same style (e.g., all filled, all
outlined, same corner radius).
• Use a Grid: Design on a grid (e.g., 24x24 pixels) to
ensure all icons have the same visual weight.
• Tools You Can Use:
– Figma (Free & Powerful): The industry standard for UI/UX
design.
– Canva (Free & Easy): Great for beginners with templates.
– Adobe Illustrator (Professional): Used for advanced vector
graphics.
Putting It All Together: Your Workflow
• Start with the Document: Write your
Requirements Spec. Decide on the features.
• Design the Flow: Sketch wireframes for all
screens, including the Login screen.
• Create the Assets: Design the final mockups and
create your custom icon set.
• Handoff: This package of documents and designs
is what a developer would use to build the app.
• By following these steps, you move from a vague
idea to a clear, actionable plan, which is the
foundation of any successful software project.
 Analyze Different Programming
Languages for Mobile App
Development
• Choosing a language is like choosing a tool for
a job. Each has its strengths and weaknesses.
Native Development (Building for one
specific platform)
Platform Language Pros Cons Best For

High-
- Official, modern
- Only works on performanc
language
Kotlin (M Android e games,
- Safer, less code
Android odern - Need to learn apps using
than Java
Standard) a new language complex
- Excellent
for iOS device
performance
features

- Fast, modern,
easy to learn
- Only works on Premium,
Swift (Mo - Designed by
Apple devices high-fidelity
iOS dern Apple for iOS
- Requires a iOS-only
Standard) - Great
Mac to develop apps
performance &
safety
 Cross-Platform Development (One
codebase for both Android & iOS)
Framework Language Pros Cons Best For

- Single code
for both Startups,
- Larger app
platforms MVP's, apps
size
Flutter Dart - Fast needing a
- Newer
performance custom
ecosystem
- Custom, branded look
beautiful UI

- Single -
codebase Performance
Companies
- Huge can lag
with web
community & slightly
React Native JavaScript teams,
libraries - Can need
social/media
- Web native code
apps
knowledge is for some
transferable features
• For learning, starting with Kotlin
(Android) or Swift (iOS) gives you a deep
understanding of mobile fundamentals. For
building a real-world app quickly for both
platforms, Flutter is an excellent choice.
 Familiarize with Mobile Application
Programming Interface (API)
• What is an API? Think of an API as a Waiter in a
Restaurant.
• You (The App) are the customer.
• The Kitchen is a remote server that holds data
(like weather info, user profiles, news).
• You can't go into the kitchen yourself.
• So, you tell the Waiter (API) what you want (e.g.,
"get today's weather").
• The waiter goes to the kitchen, gets the data, and
brings it back to you.
 Familiarize with Mobile Application
Programming Interface (API)
• In Technical Terms: An API is a set of rules and tools
that allows different software applications to
communicate with each other. Your mobile app uses
APIs to send and receive data from the internet.
Common Uses in Mobile Apps:
• Login: Your app sends username/password to a
server's API to verify.
• Show Live Data: Fetching the latest news, sports
scores, or weather.
• Save Data Online: Storing user profiles or app data in
the cloud.
Develop a Goal of the Mobile App
• Before writing code, you must answer "Why?". A
clear goal is your project's compass.
• Use this simple formula:
To [verb] [problem/pain point] for [target
audience] by [unique approach].
• Bad, Vague Goal: "Make a student app."
• Good, Clear Goal: "To help diploma students
track and manage their assignment deadlines
effectively by providing a simple, shared
calendar and task list."
 Breakdown of the Good Goal:
• Verb: To help... track and manage
• Problem: assignment deadlines
• Target Audience: diploma students
• Unique Approach: simple, shared calendar
and task list
Write Out the Features of the Mobile
App
• Features are the specific things the user
can DO to achieve the app's goal. List them based
on the goal from part (c).
• App Goal: To help diploma students track and
manage their assignment deadlines effectively.
• Feature List:
• User Onboarding & Authentication
– User can register for a new account.
– User can log in to their account.
– User can reset a forgotten password.
 Write Out the Features of the Mobile
App
• Dashboard
– User sees a summary of upcoming assignments (within 7 days).
– User can quickly access their most recent subjects.
• Assignment Management
– User can Add a new assignment (with Title, Subject, Due Date, Priority Level).
– User can View a list of all assignments, sorted by date.
– User can Edit an existing assignment.
– User can Mark an assignment as complete.
– User can Delete an assignment.
• Subject Management
– User can add and name their subjects (e.g., "Mathematics," "Programming").
• Profile
– User can view and edit their profile name and email.
Create Mobile App Graphic Design
• This is where you make the features from part
(d) visual and easy to use.
• The 3-Step Design Process:
• Wireframing (The Skeleton): Simple, black
and white sketches that define the layout and
structure. Focus on "where things go."
• Image Suggestion: A hand-drawn wireframe
of the app's "Add Assignment" screen, using
just boxes and lines.
Create Mobile App Graphic Design
• Mockups (The Skin): High-fidelity, visual designs of the
wireframes. This includes the final Color Palette, Fonts
(Typography), and imagery.
– Example Color Palette: Blue (Trust), Green (Progress),
White (Clean).
– Example Font: Sans-serif (Modern, clean, easy to read).
• 🎨 Image Suggestion: The final, colored mockup of the
same "Add Assignment" screen, showing the chosen
colors, fonts, and styled buttons.
• Iconography (The Details): Create a consistent set of
icons for navigation and actions (e.g., a plus ⊕ for
"add," a checkmark ✓ for "complete").
 Develop the Mobile App
• This is the implementation phase, where you
write code to bring the design to life.
• A Simplified Development Workflow:
• Set Up the Project: Create a new project in
Android Studio (for Kotlin), Xcode (for Swift),
or VS Code (for Flutter).
• Build the Screens: Create the user interface
(UI) for each screen (Login, Dashboard, etc.)
based on your mockups.
 Develop the Mobile App
• Make it Interactive (Functionality): Write code to handle
button presses, form inputs, and screen navigation.
– Example: Code the "Add Assignment" button to save the user's
input to a list.
• Integrate the Backend/APIs: Connect your app to the
internet. If your app needs to save data online, this is
where you write code to call APIs.
• Test & Debug: Constantly run your app on emulators and
real devices to find and fix bugs (errors in the code).
• Refine & Polish: Add final animations, improve the loading
states, and ensure the app is smooth and user-friendly.
 Co-create Requirements with the
Users
• What is it? This is the process of collaborating
directly with your potential users to understand
their problems and define the app's
features together, rather than just guessing what
they need.
• Why it's important: You are not your user. What
you think is a good feature might be useless to
them. Co-creation ensures you build an app
people will actually use and value.
 How to do it (Practical Methods):
• Conduct User Interviews:
– Goal: Have open-ended conversations to understand their pain points.
– Example Questions for a "Student Planner" app:
• "Can you walk me through how you currently keep track of your
assignments?"
• "What's the most frustrating part of managing your deadlines?"
• "What would a perfect study helper app do for you?"
• Create User Stories:
– This is a simple, powerful format to capture a requirement from the
user's perspective.
– Template: As a [type of user], I want to [perform some task], so that I
can [achieve some goal].
– Example from co-creation: "As a diploma student, I want to get a
notification 2 days before an assignment is due, so that I don't forget
to start working on it."
 Identify Input Features
• What is it? Input features are how the
user gives data and commands to the app.
They are the triggers for any action.
• Think of it as: "What information does the
app need from the user to perform its job?"
 Common Input Features & Examples
for a Student Planner App:
Input Feature Example in the App

Tapping a " + " button to add a new

Tap / Press
assignment.

Typing the assignment title or notes

Text Entry
into a text field.

Choosing a due date from a calendar

Selection
picker.

Selecting a priority level (High,

Selection
Medium, Low) from a dropdown.

Toggling a "Remind Me" switch ON or

Switch Toggle
OFF.

Entering an email and password on

Login Credentials
the login screen.
 Identify Processing Features
• What is it? Processing features are
the "brain" of the operation. This is what the
app does internally with the input data. The
user doesn't see this happening directly, but
they see the result.
• Think of it as: "What calculations, decisions,
or data management happens behind the
scenes?"
 Common Processing Features &
Examples:
PROCESSING
EXAMPLE IN THE APP
FEATURE

Checking if the entered email is in a valid format (e.g.,

Data Validation
contains "@").

Verifying if the login email and password match a record in

Authentication
the database.

Sorting & Filtering Sorting the list of assignments by due date (soonest first).

Calculating how many days are left until an assignment's

Calculation
due date.

Data Saving a new assignment to the phone's local storage or a

Storage/Retrieval cloud database.

Triggering Scheduling a push notification based on the assignment's

Notifications due date and user's reminder settings.
 Identify Output Features
• What is it? Output features are how the
app presents information and results back to
the user. It's the app's response.
• Think of it as: "What does the user see, hear,
or feel as a result of their input and the app's
processing?"
 Common Output Features &
Examples:
Output Feature Example in the App

Showing the list of upcoming assignments on the

Visual Display
dashboard.

Confirmation Displaying "Assignment Saved!" after the user clicks

Message "Save".

Showing "Invalid Email" if the user enters a bad

Error Message
email format.

A pop-up alert saying "Math Assignment due

Push Notification
tomorrow!"

An assignment item visually changing color or

Status Change
getting a "Completed" checkmark.

Displaying a chart showing completed vs. pending

Generated Report
assignments for the month.
 Analyze Mobile Application
Development Environment
• What is it? This is your "digital workshop"—the
set of tools and software you need to start
building the app.
• Key Components of the Environment:
• Integrated Development Environment (IDE): The
main software where you write, test, and debug
your code.
– Android (Kotlin/Java): Android Studio
– iOS (Swift): Xcode (only runs on macOS)
– Cross-Platform (Flutter/Dart): Visual Studio
Code or Android Studio
 Analyze Mobile Application
Development Environment
• Software Development Kit (SDK): A collection of
tools, libraries, and documentation provided by
Google/Apple for their respective platforms (e.g.,
Android SDK, iOS SDK).
• Emulator/Simulator: A virtual mobile device that
runs on your computer, allowing you to test the
app without a physical phone.
• Version Control System (e.g., Git with
GitHub/GitLab): Essential for tracking changes in
your code and collaborating with others.
 List Identified Mobile Application
Requirements
• This is the final, consolidated list that brings together
everything from co-creation, input, processing, and
output. It's your official "To-Build" list.
• Example: Student Planner App - Consolidated
Requirements
• 1. User Account Management
• Input: Email, Password text fields on login/registration
screens.
• Processing: Validate email format. Authenticate user
credentials against the database.
• Output: Log the user in on success; show an error
message on failure.
 List Identified Mobile Application
Requirements
• 2. Assignment Creation & Management
• Input: Tap "+" button. Enter title, select
subject, choose due date, set priority.
• Processing: Save assignment data to local
database. Schedule a reminder notification if
enabled.
• Output: Show new assignment in the list.
Show "Assignment Saved" confirmation.
 List Identified Mobile Application
Requirements
• 3. Dashboard Overview
• Input: App launch or navigation to the home
screen.
• Processing: Retrieve assignments from the
database. Sort them by due date. Filter to
show only upcoming ones.
• Output: Display a sorted, scrollable list of
assignments, each showing title, subject, and
days until due.
 List Identified Mobile Application
Requirements
• 4. Notification Reminders
• Input: User enabling the "Remind Me" toggle
when creating/editing an assignment.
• Processing: Calculate the notification time
(e.g., 2 days before due). Schedule it with the
OS.
• Output: A push notification appears on the
user's phone at the scheduled time.
 Describe Software Testing
• Software testing is the process of checking if your mobile app works
as intended and is free of bugs (errors). It's like being a quality
inspector in a factory, but for your code. Think of testing a recipe.
You follow the steps (use the app) to see if the final dish (the
output) is what you expected. If it's too salty or doesn't rise, you
found a "bug" in the recipe.
The Main Goals of Testing are to:
• Find Bugs: Identify errors, crashes, or unexpected behavior before
your users do.
• Ensure Quality: Verify that the app is stable, usable, and performs
well.
• Validate Requirements: Confirm that all the features you planned
actually work correctly.
 Set Criteria for Testing a Mobile App
• Testing criteria are the rules and standards you use to
judge if your app has passed or failed a test. They are
your checklist for quality.
• Key Testing Criteria to Define:
• Functional Correctness: Does the feature work as
specified? Example: "When a user taps 'Log In' with
correct credentials, the app must proceed to the
Dashboard screen."
• Usability: Is the app easy and intuitive to use?
Example: "A new user should be able to add their first
assignment in less than 2 minutes without
instructions."
 Set Criteria for Testing a Mobile App
• Performance: Is the app fast and responsive?
Example: "The app should launch in under 3 seconds
on a mid-range Android device."
• Compatibility: Does it work on different devices and
OS versions? Example: "The app must function
correctly on Android 11, 12, and 13."
• Security: Is user data safe? Example: "User passwords
must be encrypted and not stored as plain text."
• Battery & Data Usage: Is the app efficient?
Example: "Background syncing should not drain the
battery excessively."
 Involve Users of the Application (Co-
Testing) to Set Testing Criteria
• What is it? Co-testing means involving real
potential users in the testing process. They
provide feedback that you, as the developer,
might never think of.
• Why it's crucial: You are too close to the
project. A real user will try to do things in
unexpected ways, revealing hidden usability
issues.
• How to Involve Users in Setting Criteria:
 Involve Users of the Application (Co-
Testing) to Set Testing Criteria
• Ask them about their "Job to be Done": "What is the
single most important thing this app must do for you?"
Their answer becomes a top-priority testing criterion.
• Observe them using a prototype: Watch where they
hesitate, get confused, or make mistakes. Their
struggles directly inform your usability testing criteria.
– User Feedback: "I didn't know that icon was for 'Add
Assignment'."
– Resulting Criterion: "The 'Add' function must be clearly
labeled with text or a universally understood icon."
 Prepare a Testing Schedule
• A testing schedule keeps the process
organized and ensures you don't miss
anything. It answers: What to test, When, and
Who is responsible?
Simple Testing Schedule for a Student
Project:
Test Phase What to Test Who Tests Timeline

Individual
functions &
components
Unit Testing Developer Week 1
(e.g., Does the
date calculator
work?).

How different
modules work
Integration together (e.g.,
Developer Week 2
Testing Does saving an
assignment
update the list?).
Simple Testing Schedule for a Student
Project:
Test Phase What to Test Who Tests Timeline

The complete,
integrated app
Developer &
System Testing against all Week 3
Peer Tester
criteria from
section (b).

User The app with a

Acceptance (Co- small group of 5-10 End-Users Week 4
Testing) real end-users.
Test the Mobile App According to the
Set Testing Criteria
• This is the "hands-on" phase where you
execute your plan. For each feature, you
follow a test case.
• Example of a Formal Test Case:
• Feature Being Tested: User Login
• Testing Criterion: "User can successfully log in
with valid credentials and is redirected to the
Dashboard."
 Test Steps:
1. Launch the app.
2. Enter a registered email
(e.g., student@[Link]).
3. Enter the correct password.
4. Tap the "Log In" button.
 Test Steps:
• Expected Result: The app navigates to the Dashboard screen.
• Actual Result: [To be filled during testing] - The app navigates to the
Dashboard.
• Status: PASS ✅
• Another Test Case: "App shows an error with an invalid password."
• Test Steps: ... (enter a wrong password) ...
• Expected Result: Error message: "Invalid email or password."
• Actual Result: [To be filled] - The message "Wrong login" appears.
• Status: FAIL ✅ (Because the message text wasn't as specified).
 Co-Evaluate the Working of the
Mobile App with the End-Users
• After co-testing, you must analyze the
feedback with the users to decide what to
improve.
• How to Co-Evaluate:
• Conduct a Feedback Session: Gather your co-
testers (individually or in a group).
 Co-Evaluate the Working of the
Mobile App with the End-Users
• Ask Structured Questions:
– "On a scale of 1-5, how easy was it to add a new assignment?"
– "What was the most frustrating part of using the app?"
– "What one thing would make this app more useful for you?"
• Prioritize Findings Together: Create a simple 2x2 matrix:
– High Impact / Low Effort: Fix these first! (e.g., changing
confusing button text).
– High Impact / High Effort: Major features for the next version
(e.g., adding a group collaboration feature).
– Low Impact / Low Effort: "Nice-to-have" minor tweaks.
– Low Impact / High Effort: Deprioritize or discard.