23.1 Requirements and feasibility

Learning objectives

By the end of this section, you will be able to:

• Define and analyse the requirements of a software engineering problem

• Demonstrate stakeholder needs and market opportunities through research

• Assess scheduling and financial feasibility with realistic constraints

• Generate functional and non-functional requirements specifications

• Define appropriate data structures and data types for solutions

• Establish clear project boundaries and scope definitions

---

Understanding requirements analysis

Requirements analysis is the foundation of successful software engineering projects. It involves systematically identifying what stakeholders need from a software solution and determining whether those needs can realistically be met within available constraints.

Key principles of requirements analysis:

• Stakeholder-centered approach: Understanding who will use, benefit from, or be affected by the solution

• Evidence-based decisions: Using research and data to validate assumptions about needs

• Constraint awareness: Recognising limitations in time, budget, skills, and technology

• Clear documentation: Recording requirements in specific, measurable, achievable terms

Stakeholder identification and needs analysis

Effective requirements analysis begins with identifying all stakeholders and understanding their specific needs, goals, and constraints.

Primary stakeholder categories:

1. End users: People who will directly interact with the software

2. Business stakeholders: Decision-makers, product owners, and budget holders

3. Technical stakeholders: Developers, system administrators, and maintainers

4. Regulatory stakeholders: Compliance officers, legal teams, and auditors

Methods for gathering stakeholder needs:

class StakeholderAnalysis:
    """
    Framework for systematic stakeholder identification and needs assessment.
    Supports structured gathering and documentation of requirements.
    """

    def __init__(self):
        self.stakeholders = {}
        self.requirements = []
        self.constraints = []

    def add_stakeholder(self, name, role, influence_level, interest_level):
        """
        Add stakeholder with influence and interest assessment.

        Args:
            name: Stakeholder name or group identifier
            role: Their role in relation to the project
            influence_level: High/Medium/Low - ability to impact project success
            interest_level: High/Medium/Low - level of engagement with project
        """
        self.stakeholders[name] = {
            'role': role,
            'influence': influence_level,
            'interest': interest_level,
            'needs': [],
            'constraints': [],
            'contact_method': None
        }

    def record_stakeholder_need(self, stakeholder_name, need_description, priority, rationale):
        """
        Document a specific need expressed by a stakeholder.

        Args:
            stakeholder_name: Which stakeholder expressed this need
            need_description: Clear description of what they need
            priority: High/Medium/Low importance to stakeholder
            rationale: Why this need exists and its business justification
        """
        if stakeholder_name in self.stakeholders:
            need = {
                'description': need_description,
                'priority': priority,
                'rationale': rationale,
                'source': stakeholder_name,
                'date_recorded': '2025-09-20'  # In practice, use datetime.now()
            }
            self.stakeholders[stakeholder_name]['needs'].append(need)
            return need
        else:
            raise ValueError(f"Stakeholder {stakeholder_name} not found. Add stakeholder first.")

    def conduct_stakeholder_interview(self, stakeholder_name, questions, responses):
        """
        Structure stakeholder interview data collection.

        Args:
            stakeholder_name: Who was interviewed
            questions: List of questions asked
            responses: Corresponding responses received
        """
        if stakeholder_name not in self.stakeholders:
            raise ValueError(f"Stakeholder {stakeholder_name} not found")

        interview_data = {
            'date': '2025-09-20',
            'questions': questions,
            'responses': responses,
            'follow_up_needed': []
        }

        # Extract needs from responses
        for i, response in enumerate(responses):
            if response and len(response.strip()) > 0:
                # In practice, this would involve more sophisticated parsing
                potential_need = f"Need identified from Q{i+1}: {response[:100]}..."
                self.record_stakeholder_need(
                    stakeholder_name, 
                    potential_need, 
                    'Medium',  # Default priority
                    f"Expressed during interview on {interview_data['date']}"
                )

        self.stakeholders[stakeholder_name]['interview_data'] = interview_data

    def generate_requirements_matrix(self):
        """
        Create a requirements traceability matrix linking needs to stakeholders.
        Returns structured data for requirements documentation.
        """
        matrix = []
        requirement_id = 1

        for stakeholder_name, stakeholder_data in self.stakeholders.items():
            for need in stakeholder_data['needs']:
                matrix.append({
                    'req_id': f'REQ-{requirement_id:03d}',
                    'stakeholder': stakeholder_name,
                    'description': need['description'],
                    'priority': need['priority'],
                    'rationale': need['rationale'],
                    'status': 'Identified',
                    'type': 'Functional'  # Default - to be refined later
                })
                requirement_id += 1

        return matrix

    def prioritise_stakeholders(self):
        """
        Create stakeholder priority matrix based on influence and interest levels.
        Helps focus engagement efforts on most critical stakeholders.
        """
        priority_matrix = {
            'high_influence_high_interest': [],  # Manage closely
            'high_influence_low_interest': [],   # Keep satisfied
            'low_influence_high_interest': [],   # Keep informed
            'low_influence_low_interest': []     # Monitor
        }

        for name, data in self.stakeholders.items():
            influence = data['influence'].lower()
            interest = data['interest'].lower()

            if influence == 'high' and interest == 'high':
                priority_matrix['high_influence_high_interest'].append(name)
            elif influence == 'high' and interest == 'low':
                priority_matrix['high_influence_low_interest'].append(name)
            elif influence == 'low' and interest == 'high':
                priority_matrix['low_influence_high_interest'].append(name)
            else:
                priority_matrix['low_influence_low_interest'].append(name)

        return priority_matrix

# Example usage demonstrating stakeholder analysis process
def demonstrate_stakeholder_analysis():
    """
    Practical example of stakeholder analysis for a school management system.
    Shows how to systematically gather and organize stakeholder requirements.
    """

    print("STAKEHOLDER ANALYSIS EXAMPLE")
    print("=" * 32)
    print("Project: School Student Information System")
    print()

    # Initialize analysis framework
    analysis = StakeholderAnalysis()

    # Add key stakeholders
    analysis.add_stakeholder("Students", "Primary end users", "Medium", "High")
    analysis.add_stakeholder("Teachers", "Primary end users", "High", "High") 
    analysis.add_stakeholder("Parents", "Secondary users", "Medium", "Medium")
    analysis.add_stakeholder("School Admin", "System administrators", "High", "High")
    analysis.add_stakeholder("IT Department", "Technical support", "High", "Medium")
    analysis.add_stakeholder("Education Department", "Regulatory oversight", "High", "Low")

    # Record specific stakeholder needs
    analysis.record_stakeholder_need(
        "Students", 
        "Access grades and assignment feedback quickly",
        "High",
        "Students need timely feedback to improve academic performance"
    )

    analysis.record_stakeholder_need(
        "Teachers",
        "Efficiently record and track student progress", 
        "High",
        "Teachers spend significant time on administrative tasks"
    )

    analysis.record_stakeholder_need(
        "Parents",
        "Monitor child's academic progress and attendance",
        "High", 
        "Parents want to support their children's education effectively"
    )

    analysis.record_stakeholder_need(
        "School Admin",
        "Generate reports for compliance and decision-making",
        "High",
        "Administration needs data for regulatory reporting and strategic planning"
    )

    # Demonstrate interview process
    teacher_questions = [
        "What are your main challenges with the current grade recording system?",
        "How much time do you spend on administrative tasks daily?", 
        "What features would help you be more effective in the classroom?"
    ]

    teacher_responses = [
        "The current system is slow and crashes frequently during peak times",
        "About 2 hours per day on data entry and report generation",
        "Automated attendance, integrated lesson planning, and parent communication tools"
    ]

    analysis.conduct_stakeholder_interview("Teachers", teacher_questions, teacher_responses)

    # Generate requirements matrix
    requirements_matrix = analysis.generate_requirements_matrix()

    print("REQUIREMENTS TRACEABILITY MATRIX")
    print("-" * 35)
    for req in requirements_matrix[:3]:  # Show first 3 for brevity
        print(f"ID: {req['req_id']}")
        print(f"Stakeholder: {req['stakeholder']}")
        print(f"Description: {req['description']}")
        print(f"Priority: {req['priority']}")
        print()

    # Show stakeholder prioritization
    priority_matrix = analysis.prioritise_stakeholders()

    print("STAKEHOLDER PRIORITY MATRIX")
    print("-" * 27)
    print("Manage Closely (High Influence, High Interest):")
    for stakeholder in priority_matrix['high_influence_high_interest']:
        print(f"  • {stakeholder}")

    print("\nKeep Satisfied (High Influence, Low Interest):")
    for stakeholder in priority_matrix['high_influence_low_interest']:
        print(f"  • {stakeholder}")

    return analysis

# Run the demonstration
if __name__ == "__main__":
    stakeholder_analysis = demonstrate_stakeholder_analysis()

Market and user research methods

Validating stakeholder needs requires systematic research to understand the broader context and confirm that proposed solutions address real problems.

Research approaches:

1. User surveys and questionnaires: Quantitative data on user preferences and pain points

2. Market analysis: Understanding existing solutions, competition, and market gaps

3. User observation: Watching how people currently perform tasks and identify inefficiencies

4. Competitive analysis: Evaluating what similar solutions exist and their strengths/weaknesses

🔍 View Larger

DocumentationFeasibility AnalysisScope Definition• Primary users• Business stakeholders• Technical teams• Regulatory bodies• Competitive analysis• User surveys• Industry trends• Gap analysis• Technical feasibility• Financial viability• Timeline constraints• Resource availability

---

Feasibility assessment

Feasibility assessment determines whether identified requirements can realistically be implemented within project constraints. This involves evaluating technical, financial, and scheduling factors.

Financial feasibility analysis

Financial feasibility examines whether the project can be completed within budget constraints and whether the expected benefits justify the investment.

Key financial considerations:

• Development costs: Personnel, tools, infrastructure, and third-party services

• Operational costs: Hosting, maintenance, support, and licensing fees

• Opportunity costs: What alternatives are foregone by pursuing this project

• Return on investment: Expected benefits compared to total investment

class FinancialFeasibilityAnalysis:
    """
    Framework for systematic financial feasibility assessment.
    Evaluates costs, benefits, and financial viability of software projects.
    """

    def __init__(self, project_name, duration_months):
        self.project_name = project_name
        self.duration_months = duration_months
        self.development_costs = {}
        self.operational_costs = {}
        self.expected_benefits = {}
        self.risks = []

    def add_development_cost(self, category, description, amount, justification):
        """
        Record a one-time development cost.

        Args:
            category: Cost category (personnel, tools, infrastructure, etc.)
            description: Specific cost item description
            amount: Cost in dollars
            justification: Why this cost is necessary
        """
        if category not in self.development_costs:
            self.development_costs[category] = []

        self.development_costs[category].append({
            'description': description,
            'amount': amount,
            'justification': justification
        })

    def add_operational_cost(self, category, description, monthly_amount, justification):
        """
        Record ongoing operational costs.

        Args:
            category: Cost category (hosting, support, licensing, etc.)
            description: Specific cost item description
            monthly_amount: Monthly cost in dollars
            justification: Why this ongoing cost is necessary
        """
        if category not in self.operational_costs:
            self.operational_costs[category] = []

        self.operational_costs[category].append({
            'description': description,
            'monthly_amount': monthly_amount,
            'annual_amount': monthly_amount * 12,
            'justification': justification
        })

    def add_expected_benefit(self, category, description, annual_value, confidence_level):
        """
        Record expected financial benefits from the project.

        Args:
            category: Benefit type (cost_savings, revenue_increase, efficiency_gain)
            description: Specific benefit description
            annual_value: Annual financial value in dollars
            confidence_level: High/Medium/Low confidence in achieving this benefit
        """
        if category not in self.expected_benefits:
            self.expected_benefits[category] = []

        self.expected_benefits[category].append({
            'description': description,
            'annual_value': annual_value,
            'confidence': confidence_level,
            'present_value': self._calculate_present_value(annual_value, 3)  # 3 year horizon
        })

    def _calculate_present_value(self, annual_amount, years, discount_rate=0.08):
        """
        Calculate present value of future benefits using discount rate.
        Standard financial analysis technique for comparing future benefits to current costs.
        """
        total_pv = 0
        for year in range(1, years + 1):
            total_pv += annual_amount / ((1 + discount_rate) ** year)
        return total_pv

    def calculate_total_development_cost(self):
        """Calculate total one-time development costs across all categories."""
        total = 0
        for category, items in self.development_costs.items():
            for item in items:
                total += item['amount']
        return total

    def calculate_annual_operational_cost(self):
        """Calculate total annual operational costs."""
        total = 0
        for category, items in self.operational_costs.items():
            for item in items:
                total += item['annual_amount']
        return total

    def calculate_total_expected_benefits(self):
        """Calculate total present value of expected benefits."""
        total = 0
        for category, items in self.expected_benefits.items():
            for item in items:
                # Apply confidence weighting
                confidence_weight = {'High': 0.9, 'Medium': 0.7, 'Low': 0.5}
                weight = confidence_weight.get(item['confidence'], 0.5)
                total += item['present_value'] * weight
        return total

    def calculate_roi(self):
        """
        Calculate Return on Investment (ROI) for the project.
        ROI = (Benefits - Costs) / Costs * 100
        """
        total_costs = self.calculate_total_development_cost() + (self.calculate_annual_operational_cost() * 3)
        total_benefits = self.calculate_total_expected_benefits()

        if total_costs == 0:
            return float('inf')

        roi = ((total_benefits - total_costs) / total_costs) * 100
        return roi

    def generate_feasibility_report(self):
        """Generate comprehensive financial feasibility report."""
        development_cost = self.calculate_total_development_cost()
        annual_operational_cost = self.calculate_annual_operational_cost()
        total_benefits = self.calculate_total_expected_benefits()
        roi = self.calculate_roi()

        report = {
            'project_name': self.project_name,
            'analysis_date': '2025-09-20',
            'financial_summary': {
                'total_development_cost': development_cost,
                'annual_operational_cost': annual_operational_cost,
                'three_year_operational_cost': annual_operational_cost * 3,
                'total_investment': development_cost + (annual_operational_cost * 3),
                'expected_benefits_pv': total_benefits,
                'net_present_value': total_benefits - (development_cost + (annual_operational_cost * 3)),
                'roi_percentage': roi
            },
            'feasibility_assessment': self._assess_financial_feasibility(roi, total_benefits, development_cost),
            'cost_breakdown': self.development_costs,
            'benefit_breakdown': self.expected_benefits
        }

        return report

    def _assess_financial_feasibility(self, roi, benefits, costs):
        """Provide qualitative assessment of financial feasibility."""
        if roi > 50:
            return "Highly Feasible - Strong ROI expected"
        elif roi > 20:
            return "Feasible - Positive ROI with good returns"
        elif roi > 0:
            return "Marginally Feasible - Positive but modest returns"
        elif roi > -20:
            return "Questionable - Potential loss, requires careful review"
        else:
            return "Not Feasible - Significant financial risk"

def demonstrate_financial_feasibility():
    """
    Practical example of financial feasibility analysis for a school system project.
    """
    print("FINANCIAL FEASIBILITY ANALYSIS")
    print("=" * 32)

    # Initialize analysis for 6-month development project
    analysis = FinancialFeasibilityAnalysis("School Management System", 6)

    # Add development costs
    analysis.add_development_cost(
        "Personnel", 
        "Senior Developer (6 months @ $8000/month)", 
        48000,
        "Lead development and architecture decisions"
    )

    analysis.add_development_cost(
        "Personnel",
        "Junior Developer (6 months @ $5000/month)", 
        30000,
        "Implementation and testing support"
    )

    analysis.add_development_cost(
        "Tools",
        "Development tools and software licenses",
        3000,
        "IDE licenses, testing tools, design software"
    )

    analysis.add_development_cost(
        "Infrastructure", 
        "Development and testing environments",
        2000,
        "Cloud hosting for development and staging"
    )

    # Add operational costs
    analysis.add_operational_cost(
        "Hosting",
        "Production cloud hosting", 
        200,
        "Application hosting and database services"
    )

    analysis.add_operational_cost(
        "Support",
        "Technical support and maintenance",
        500,
        "Bug fixes, updates, and user support"
    )

    analysis.add_operational_cost(
        "Licensing",
        "Third-party software licenses",
        100,
        "Database licenses and API services"
    )

    # Add expected benefits
    analysis.add_expected_benefit(
        "Cost Savings",
        "Reduced administrative time for teachers",
        25000,
        "High"
    )

    analysis.add_expected_benefit(
        "Cost Savings", 
        "Reduced paper and printing costs",
        3000,
        "High"
    )

    analysis.add_expected_benefit(
        "Efficiency Gain",
        "Improved student outcomes through better tracking",
        15000,
        "Medium"
    )

    # Generate and display report
    report = analysis.generate_feasibility_report()

    print(f"Project: {report['project_name']}")
    print(f"Analysis Date: {report['analysis_date']}")
    print()

    summary = report['financial_summary']
    print("FINANCIAL SUMMARY")
    print("-" * 17)
    print(f"Total Development Cost: ${summary['total_development_cost']:,.2f}")
    print(f"Annual Operational Cost: ${summary['annual_operational_cost']:,.2f}")
    print(f"Total 3-Year Investment: ${summary['total_investment']:,.2f}")
    print(f"Expected Benefits (PV): ${summary['expected_benefits_pv']:,.2f}")
    print(f"Net Present Value: ${summary['net_present_value']:,.2f}")
    print(f"Return on Investment: {summary['roi_percentage']:.1f}%")
    print()

    print("FEASIBILITY ASSESSMENT")
    print("-" * 22)
    print(f"Status: {report['feasibility_assessment']}")

    return analysis

# Run demonstration
if __name__ == "__main__":
    financial_analysis = demonstrate_financial_feasibility()

Scheduling feasibility

Scheduling feasibility evaluates whether the project can be completed within required timeframes given available resources and dependencies.

Key scheduling considerations:

• Resource availability: When team members and tools will be available

• Task dependencies: What work must be completed before other work can begin

• Risk buffers: Time allocated for handling unexpected delays or complications

• Milestone alignment: Ensuring delivery dates align with stakeholder expectations

---

Functional and non-functional requirements

Requirements fall into two main categories that serve different purposes but are equally important for project success.

Functional requirements

Functional requirements describe what the system must do - the specific behaviours, features, and capabilities that stakeholders need.

Characteristics of good functional requirements:

• Specific: Clearly defined behaviour with no ambiguity

• Measurable: Can be verified through testing or demonstration

• Achievable: Technically possible within project constraints

• Relevant: Directly supports stakeholder needs

• Time-bound: Clear expectations for when functionality will be available

Examples of functional requirements:

class FunctionalRequirement:
    """
    Template for documenting functional requirements with clear acceptance criteria.
    Ensures requirements are testable and traceable to stakeholder needs.
    """

    def __init__(self, requirement_id, title, description, stakeholder_source):
        self.requirement_id = requirement_id
        self.title = title
        self.description = description
        self.stakeholder_source = stakeholder_source
        self.acceptance_criteria = []
        self.test_scenarios = []
        self.priority = None
        self.status = "Draft"

    def add_acceptance_criterion(self, criterion):
        """
        Add specific, testable criterion that defines when requirement is satisfied.

        Args:
            criterion: Clear statement of expected behaviour or outcome
        """
        self.acceptance_criteria.append(criterion)

    def add_test_scenario(self, scenario_description, expected_outcome):
        """
        Add test scenario that validates the requirement.

        Args:
            scenario_description: Steps to test the requirement
            expected_outcome: What should happen when test is performed
        """
        self.test_scenarios.append({
            'scenario': scenario_description,
            'expected_outcome': expected_outcome
        })

    def set_priority(self, priority_level):
        """Set requirement priority: Critical, High, Medium, or Low."""
        valid_priorities = ["Critical", "High", "Medium", "Low"]
        if priority_level in valid_priorities:
            self.priority = priority_level
        else:
            raise ValueError(f"Priority must be one of: {valid_priorities}")

    def mark_approved(self):
        """Mark requirement as approved by stakeholders."""
        self.status = "Approved"

    def generate_requirement_document(self):
        """Generate formatted requirement documentation."""
        doc = f"""
FUNCTIONAL REQUIREMENT: {self.requirement_id}
Title: {self.title}
Source: {self.stakeholder_source}
Priority: {self.priority}
Status: {self.status}

DESCRIPTION:
{self.description}

ACCEPTANCE CRITERIA:
"""
        for i, criterion in enumerate(self.acceptance_criteria, 1):
            doc += f"{i}. {criterion}\n"

        doc += "\nTEST SCENARIOS:\n"
        for i, scenario in enumerate(self.test_scenarios, 1):
            doc += f"{i}. Scenario: {scenario['scenario']}\n"
            doc += f"   Expected: {scenario['expected_outcome']}\n"

        return doc

def demonstrate_functional_requirements():
    """
    Example functional requirements for a school management system.
    Shows how to document requirements with clear acceptance criteria.
    """
    print("FUNCTIONAL REQUIREMENTS EXAMPLES")
    print("=" * 34)

    # Example 1: User authentication requirement
    auth_req = FunctionalRequirement(
        "FR-001",
        "User Authentication and Access Control", 
        "The system must authenticate users and control access to features based on user roles (Student, Teacher, Admin).",
        "School Administration"
    )

    auth_req.add_acceptance_criterion("Users must log in with valid credentials before accessing any system features")
    auth_req.add_acceptance_criterion("Failed login attempts must be logged and limited to prevent brute force attacks")
    auth_req.add_acceptance_criterion("Students can only access their own academic records")
    auth_req.add_acceptance_criterion("Teachers can access records for students in their classes")
    auth_req.add_acceptance_criterion("Administrators can access all system features and data")

    auth_req.add_test_scenario(
        "User enters correct username and password", 
        "System grants access and redirects to appropriate dashboard"
    )
    auth_req.add_test_scenario(
        "User enters incorrect password 3 times",
        "System locks account for 15 minutes and notifies user"
    )

    auth_req.set_priority("Critical")
    auth_req.mark_approved()

    # Example 2: Grade recording requirement
    grade_req = FunctionalRequirement(
        "FR-002",
        "Grade Recording and Calculation",
        "Teachers must be able to record individual assignment grades and have overall grades calculated automatically according to school grading policy.",
        "Teachers"
    )

    grade_req.add_acceptance_criterion("Teachers can enter grades for assignments, tests, and projects")
    grade_req.add_acceptance_criterion("System calculates weighted average based on assignment categories")
    grade_req.add_acceptance_criterion("Grade changes are logged with timestamp and teacher identification")
    grade_req.add_acceptance_criterion("Students and parents can view current grades within 24 hours of entry")

    grade_req.add_test_scenario(
        "Teacher enters grade for a homework assignment worth 10% of final grade",
        "System updates student's overall grade calculation immediately"
    )

    grade_req.set_priority("High")
    grade_req.mark_approved()

    # Display requirement documentation
    print(auth_req.generate_requirement_document())
    print("-" * 50)
    print(grade_req.generate_requirement_document())

    return [auth_req, grade_req]

# Run demonstration
if __name__ == "__main__":
    functional_requirements = demonstrate_functional_requirements()

Non-functional requirements

Non-functional requirements specify how the system should perform - the quality attributes and constraints that affect user experience and system operation.

Common categories of non-functional requirements:

1. Performance: Response times, throughput, and resource usage

2. Reliability: System availability and error recovery capabilities

3. Security: Data protection and access control measures

4. Usability: User interface design and accessibility standards

5. Scalability: Ability to handle increased load and user growth

6. Maintainability: Ease of updates, bug fixes, and system changes

class NonFunctionalRequirement:
    """
    Template for documenting non-functional requirements with measurable criteria.
    Focuses on quality attributes and system constraints.
    """

    def __init__(self, requirement_id, category, title, description):
        self.requirement_id = requirement_id
        self.category = category  # Performance, Security, Usability, etc.
        self.title = title
        self.description = description
        self.measurable_criteria = []
        self.testing_approach = None
        self.priority = None
        self.status = "Draft"

    def add_measurable_criterion(self, metric, target_value, measurement_method):
        """
        Add specific, measurable criterion for this non-functional requirement.

        Args:
            metric: What will be measured (e.g., "Response time", "Uptime")
            target_value: Specific target (e.g., "< 2 seconds", "> 99.5%")
            measurement_method: How it will be measured and verified
        """
        self.measurable_criteria.append({
            'metric': metric,
            'target': target_value,
            'measurement_method': measurement_method
        })

    def set_testing_approach(self, approach_description):
        """Define how this requirement will be tested and validated."""
        self.testing_approach = approach_description

    def set_priority(self, priority_level):
        """Set requirement priority: Critical, High, Medium, or Low."""
        valid_priorities = ["Critical", "High", "Medium", "Low"]
        if priority_level in valid_priorities:
            self.priority = priority_level
        else:
            raise ValueError(f"Priority must be one of: {valid_priorities}")

    def generate_requirement_document(self):
        """Generate formatted non-functional requirement documentation."""
        doc = f"""
NON-FUNCTIONAL REQUIREMENT: {self.requirement_id}
Category: {self.category}
Title: {self.title}
Priority: {self.priority}
Status: {self.status}

DESCRIPTION:
{self.description}

MEASURABLE CRITERIA:
"""
        for i, criterion in enumerate(self.measurable_criteria, 1):
            doc += f"{i}. {criterion['metric']}: {criterion['target']}\n"
            doc += f"   Measurement: {criterion['measurement_method']}\n"

        if self.testing_approach:
            doc += f"\nTESTING APPROACH:\n{self.testing_approach}\n"

        return doc

def demonstrate_non_functional_requirements():
    """
    Example non-functional requirements for a school management system.
    Shows how to specify measurable quality attributes.
    """
    print("NON-FUNCTIONAL REQUIREMENTS EXAMPLES")
    print("=" * 38)

    # Example 1: Performance requirement
    performance_req = NonFunctionalRequirement(
        "NFR-001",
        "Performance",
        "System Response Time and Throughput",
        "The system must provide fast response times to ensure productive user experience during peak usage periods."
    )

    performance_req.add_measurable_criterion(
        "Page load time",
        "< 2 seconds for 95% of requests",
        "Automated performance testing with load simulation tools"
    )
    performance_req.add_measurable_criterion(
        "Database query response", 
        "< 500 milliseconds for standard operations",
        "Database monitoring and query performance analysis"
    )
    performance_req.add_measurable_criterion(
        "Concurrent user support",
        "Support 200+ simultaneous users without degradation",
        "Load testing with simulated user scenarios"
    )

    performance_req.set_testing_approach(
        "Performance testing during development using tools like Apache JMeter. "
        "Continuous monitoring in production with alerting for threshold violations."
    )
    performance_req.set_priority("High")

    # Example 2: Security requirement
    security_req = NonFunctionalRequirement(
        "NFR-002", 
        "Security",
        "Data Protection and Access Security",
        "The system must protect sensitive student and staff information from unauthorized access and data breaches."
    )

    security_req.add_measurable_criterion(
        "Data encryption",
        "All sensitive data encrypted using AES-256 at rest and TLS 1.3 in transit",
        "Security audit and penetration testing verification"
    )
    security_req.add_measurable_criterion(
        "Password complexity",
        "Passwords must meet minimum 8 characters with complexity requirements",
        "Automated password policy validation testing"
    )
    security_req.add_measurable_criterion(
        "Session management",
        "User sessions expire after 30 minutes of inactivity",
        "Session timeout testing and user experience validation"
    )

    security_req.set_testing_approach(
        "Security testing including vulnerability scanning, penetration testing, and code security review. "
        "Regular security audits and compliance verification."
    )
    security_req.set_priority("Critical")

    # Example 3: Usability requirement
    usability_req = NonFunctionalRequirement(
        "NFR-003",
        "Usability", 
        "User Interface and Accessibility",
        "The system must be easy to use for all stakeholders and accessible to users with disabilities."
    )

    usability_req.add_measurable_criterion(
        "Learning curve",
        "New users can complete basic tasks within 15 minutes of first login",
        "User testing with representative stakeholders"
    )
    usability_req.add_measurable_criterion(
        "Accessibility compliance",
        "Meets WCAG 2.1 AA accessibility standards",
        "Automated accessibility testing and expert review"
    )
    usability_req.add_measurable_criterion(
        "Mobile responsiveness",
        "All features accessible on mobile devices with screen sizes 320px+",
        "Cross-device testing and responsive design validation"
    )

    usability_req.set_testing_approach(
        "Usability testing with real users, accessibility auditing, and responsive design testing across devices."
    )
    usability_req.set_priority("High")

    # Display requirement documentation
    print(performance_req.generate_requirement_document())
    print("-" * 60)
    print(security_req.generate_requirement_document()) 
    print("-" * 60)
    print(usability_req.generate_requirement_document())

    return [performance_req, security_req, usability_req]

# Run demonstration
if __name__ == "__main__":
    non_functional_requirements = demonstrate_non_functional_requirements()

---

Data structures and data types

Defining appropriate data structures and types is essential for implementing requirements effectively and ensuring system performance and maintainability.

Data structure selection principles

Choosing the right data structures requires understanding the operations your system will perform and the performance characteristics of different data structures.

Key considerations:

• Access patterns: How data will be read, written, and updated

• Volume: Expected size of datasets and growth over time

• Performance requirements: Speed vs. memory usage trade-offs

• Relationships: How different pieces of data connect to each other

class DataStructureAnalysis:
    """
    Framework for analyzing data requirements and selecting appropriate structures.
    Helps make informed decisions about data organization and storage.
    """

    def __init__(self, system_name):
        self.system_name = system_name
        self.entities = {}
        self.relationships = []
        self.performance_requirements = {}

    def define_entity(self, entity_name, attributes, expected_volume, primary_operations):
        """
        Define a data entity with its attributes and usage patterns.

        Args:
            entity_name: Name of the entity (e.g., "Student", "Grade", "Assignment")
            attributes: Dictionary of attribute names and their data types
            expected_volume: Estimated number of records
            primary_operations: List of main operations (Create, Read, Update, Delete, Search)
        """
        self.entities[entity_name] = {
            'attributes': attributes,
            'expected_volume': expected_volume,
            'primary_operations': primary_operations,
            'relationships': [],
            'recommended_structure': None,
            'justification': None
        }

    def add_relationship(self, entity1, entity2, relationship_type, cardinality):
        """
        Define relationship between entities.

        Args:
            entity1: Source entity name
            entity2: Target entity name
            relationship_type: Type of relationship (e.g., "has", "belongs_to", "many_to_many")
            cardinality: Relationship cardinality (e.g., "1:1", "1:many", "many:many")
        """
        relationship = {
            'entity1': entity1,
            'entity2': entity2,
            'type': relationship_type,
            'cardinality': cardinality
        }
        self.relationships.append(relationship)

        # Add to entity relationship lists
        if entity1 in self.entities:
            self.entities[entity1]['relationships'].append(relationship)
        if entity2 in self.entities:
            self.entities[entity2]['relationships'].append(relationship)

    def set_performance_requirement(self, entity_name, operation, target_time):
        """
        Set performance requirement for specific operations on entities.

        Args:
            entity_name: Entity this requirement applies to
            operation: Operation type (e.g., "search", "insert", "update")
            target_time: Target time for operation (e.g., "< 100ms")
        """
        if entity_name not in self.performance_requirements:
            self.performance_requirements[entity_name] = {}
        self.performance_requirements[entity_name][operation] = target_time

    def recommend_data_structures(self):
        """
        Analyze entities and recommend appropriate data structures.
        Considers volume, operations, and performance requirements.
        """
        for entity_name, entity_data in self.entities.items():
            operations = entity_data['primary_operations']
            volume = entity_data['expected_volume']

            # Analyze operation patterns
            needs_fast_search = 'Search' in operations
            needs_ordering = 'Sort' in operations or 'Order' in operations
            high_volume = volume > 10000
            frequent_updates = 'Update' in operations

            # Recommend structure based on analysis
            if needs_fast_search and high_volume:
                if frequent_updates:
                    recommendation = "Hash Table with Secondary Indexes"
                    justification = "Fast search (O(1)) with support for frequent updates"
                else:
                    recommendation = "Sorted Array or B-Tree"
                    justification = "Fast search (O(log n)) with memory efficiency"
            elif needs_ordering:
                recommendation = "Balanced Binary Search Tree or Skip List"
                justification = "Maintains sorted order with efficient insertions"
            elif high_volume and not frequent_updates:
                recommendation = "Array with Binary Search"
                justification = "Memory efficient with fast search for read-heavy workload"
            else:
                recommendation = "Dynamic Array (List)"
                justification = "Simple structure suitable for moderate volume and mixed operations"

            entity_data['recommended_structure'] = recommendation
            entity_data['justification'] = justification

    def generate_data_model_document(self):
        """Generate comprehensive data model documentation."""
        doc = f"""
DATA MODEL FOR {self.system_name}
{'=' * (15 + len(self.system_name))}

ENTITIES AND STRUCTURES:
"""

        for entity_name, entity_data in self.entities.items():
            doc += f"\nEntity: {entity_name}\n"
            doc += f"Expected Volume: {entity_data['expected_volume']:,} records\n"
            doc += f"Primary Operations: {', '.join(entity_data['primary_operations'])}\n"
            doc += f"Recommended Structure: {entity_data['recommended_structure']}\n"
            doc += f"Justification: {entity_data['justification']}\n"

            doc += "Attributes:\n"
            for attr_name, attr_type in entity_data['attributes'].items():
                doc += f"  • {attr_name}: {attr_type}\n"

            if entity_name in self.performance_requirements:
                doc += "Performance Requirements:\n"
                for operation, target in self.performance_requirements[entity_name].items():
                    doc += f"  • {operation}: {target}\n"

        doc += f"\nRELATIONSHIPS:\n"
        for rel in self.relationships:
            doc += f"• {rel['entity1']} {rel['type']} {rel['entity2']} ({rel['cardinality']})\n"

        return doc

def demonstrate_data_structure_analysis():
    """
    Practical example of data structure analysis for a school management system.
    Shows systematic approach to data modeling and structure selection.
    """
    print("DATA STRUCTURE ANALYSIS EXAMPLE")
    print("=" * 33)

    # Initialize analysis
    analysis = DataStructureAnalysis("School Management System")

    # Define Student entity
    analysis.define_entity(
        "Student",
        {
            'student_id': 'Integer (Primary Key)',
            'first_name': 'String (50 chars)',
            'last_name': 'String (50 chars)', 
            'email': 'String (100 chars)',
            'enrollment_date': 'Date',
            'grade_level': 'Integer',
            'active': 'Boolean'
        },
        2500,  # Expected 2,500 students
        ['Create', 'Read', 'Update', 'Search']
    )

    # Define Grade entity
    analysis.define_entity(
        "Grade",
        {
            'grade_id': 'Integer (Primary Key)',
            'student_id': 'Integer (Foreign Key)',
            'assignment_id': 'Integer (Foreign Key)',
            'score': 'Decimal (5,2)',
            'recorded_date': 'DateTime',
            'teacher_id': 'Integer (Foreign Key)'
        },
        50000,  # Expected 50,000 grade records
        ['Create', 'Read', 'Search', 'Update']
    )

    # Define Assignment entity
    analysis.define_entity(
        "Assignment", 
        {
            'assignment_id': 'Integer (Primary Key)',
            'title': 'String (200 chars)',
            'description': 'Text',
            'due_date': 'DateTime',
            'max_score': 'Decimal (5,2)',
            'category': 'String (50 chars)',
            'weight': 'Decimal (3,2)'
        },
        1000,  # Expected 1,000 assignments
        ['Create', 'Read', 'Update', 'Search', 'Sort']
    )

    # Define relationships
    analysis.add_relationship("Student", "Grade", "has", "1:many")
    analysis.add_relationship("Assignment", "Grade", "has", "1:many")

    # Set performance requirements
    analysis.set_performance_requirement("Student", "search", "< 200ms")
    analysis.set_performance_requirement("Grade", "search", "< 100ms")
    analysis.set_performance_requirement("Assignment", "sort", "< 500ms")

    # Generate recommendations
    analysis.recommend_data_structures()

    # Display analysis results
    document = analysis.generate_data_model_document()
    print(document)

    return analysis

# Run demonstration
if __name__ == "__main__":
    data_analysis = demonstrate_data_structure_analysis()

---

Scope definition and boundaries

Clear scope definition prevents project scope creep and ensures all stakeholders have aligned expectations about what will and will not be included in the solution.

Defining project boundaries

Project boundaries specify what is included in the current project and what is explicitly excluded or deferred to future phases.

Boundary categories:

1. Functional boundaries: Which features and capabilities are included

2. System boundaries: Which systems and integrations are in scope

3. User boundaries: Which user groups and use cases are supported

4. Data boundaries: Which data sources and types are included

5. Platform boundaries: Which devices, browsers, or operating systems are supported

🔍 View Larger

class ScopeDefinition:
    """
    Framework for defining and documenting project scope and boundaries.
    Helps prevent scope creep and manage stakeholder expectations.
    """

    def __init__(self, project_name, project_phase):
        self.project_name = project_name
        self.project_phase = project_phase
        self.in_scope = {}
        self.out_of_scope = {}
        self.future_scope = {}
        self.assumptions = []
        self.constraints = []
        self.dependencies = []

    def add_in_scope_item(self, category, item, description, priority):
        """
        Add item that is included in current project scope.

        Args:
            category: Scope category (features, users, data, platforms, etc.)
            item: Specific item name
            description: Detailed description of what's included
            priority: Priority level (Critical, High, Medium, Low)
        """
        if category not in self.in_scope:
            self.in_scope[category] = []

        self.in_scope[category].append({
            'item': item,
            'description': description,
            'priority': priority,
            'status': 'Planned'
        })

    def add_out_of_scope_item(self, category, item, rationale):
        """
        Add item that is explicitly excluded from current project scope.

        Args:
            category: Scope category
            item: Specific item name
            rationale: Reason for exclusion
        """
        if category not in self.out_of_scope:
            self.out_of_scope[category] = []

        self.out_of_scope[category].append({
            'item': item,
            'rationale': rationale
        })

    def add_future_scope_item(self, category, item, description, planned_phase):
        """
        Add item planned for future project phases.

        Args:
            category: Scope category
            item: Specific item name
            description: What will be included in future
            planned_phase: When this is planned (Phase 2, Phase 3, etc.)
        """
        if category not in self.future_scope:
            self.future_scope[category] = []

        self.future_scope[category].append({
            'item': item,
            'description': description,
            'planned_phase': planned_phase
        })

    def add_assumption(self, assumption_description):
        """Add project assumption that affects scope or delivery."""
        self.assumptions.append(assumption_description)

    def add_constraint(self, constraint_description):
        """Add project constraint that limits scope or delivery options."""
        self.constraints.append(constraint_description)

    def add_dependency(self, dependency_description, dependency_type):
        """
        Add external dependency that affects project scope or timeline.

        Args:
            dependency_description: What is needed from external source
            dependency_type: Internal, External, or Technical
        """
        self.dependencies.append({
            'description': dependency_description,
            'type': dependency_type
        })

    def generate_scope_document(self):
        """Generate comprehensive scope definition document."""
        doc = f"""
PROJECT SCOPE DEFINITION
{self.project_name} - {self.project_phase}
{'=' * (25 + len(self.project_name) + len(self.project_phase))}

IN SCOPE - Items included in this project phase:
"""

        for category, items in self.in_scope.items():
            doc += f"\n{category.upper()}:\n"
            for item_data in items:
                doc += f"  ✓ {item_data['item']} ({item_data['priority']})\n"
                doc += f"    {item_data['description']}\n"

        doc += f"\nOUT OF SCOPE - Items explicitly excluded:\n"
        for category, items in self.out_of_scope.items():
            doc += f"\n{category.upper()}:\n"
            for item_data in items:
                doc += f"  ✗ {item_data['item']}\n"
                doc += f"    Rationale: {item_data['rationale']}\n"

        doc += f"\nFUTURE SCOPE - Items planned for later phases:\n"
        for category, items in self.future_scope.items():
            doc += f"\n{category.upper()}:\n"
            for item_data in items:
                doc += f"  → {item_data['item']} ({item_data['planned_phase']})\n"
                doc += f"    {item_data['description']}\n"

        if self.assumptions:
            doc += f"\nPROJECT ASSUMPTIONS:\n"
            for i, assumption in enumerate(self.assumptions, 1):
                doc += f"{i}. {assumption}\n"

        if self.constraints:
            doc += f"\nPROJECT CONSTRAINTS:\n"
            for i, constraint in enumerate(self.constraints, 1):
                doc += f"{i}. {constraint}\n"

        if self.dependencies:
            doc += f"\nEXTERNAL DEPENDENCIES:\n"
            for i, dep in enumerate(self.dependencies, 1):
                doc += f"{i}. {dep['description']} ({dep['type']})\n"

        return doc

    def validate_scope_coherence(self):
        """
        Check for potential scope conflicts or inconsistencies.
        Returns list of warnings or issues found.
        """
        warnings = []

        # Check for items that might be in both in-scope and out-of-scope
        in_scope_items = set()
        out_of_scope_items = set()

        for category, items in self.in_scope.items():
            for item_data in items:
                in_scope_items.add(item_data['item'].lower())

        for category, items in self.out_of_scope.items():
            for item_data in items:
                out_of_scope_items.add(item_data['item'].lower())

        conflicts = in_scope_items.intersection(out_of_scope_items)
        if conflicts:
            warnings.append(f"Potential scope conflicts: {', '.join(conflicts)}")

        # Check for high priority items without clear descriptions
        for category, items in self.in_scope.items():
            for item_data in items:
                if item_data['priority'] in ['Critical', 'High'] and len(item_data['description']) < 20:
                    warnings.append(f"High priority item '{item_data['item']}' needs more detailed description")

        return warnings

def demonstrate_scope_definition():
    """
    Practical example of scope definition for a school management system.
    Shows systematic approach to boundary setting and expectation management.
    """
    print("SCOPE DEFINITION EXAMPLE")
    print("=" * 26)

    # Initialize scope definition for Phase 1
    scope = ScopeDefinition("School Management System", "Phase 1")

    # Define features in scope
    scope.add_in_scope_item(
        "Features",
        "User Authentication",
        "Login/logout for students, teachers, and administrators with role-based access control",
        "Critical"
    )

    scope.add_in_scope_item(
        "Features", 
        "Grade Recording",
        "Teachers can enter and update grades for assignments, tests, and projects",
        "High"
    )

    scope.add_in_scope_item(
        "Features",
        "Grade Viewing",
        "Students and parents can view current grades and progress reports",
        "High"
    )

    scope.add_in_scope_item(
        "Features",
        "Basic Reporting",
        "Generate basic grade reports and transcripts in PDF format",
        "Medium"
    )

    # Define users in scope
    scope.add_in_scope_item(
        "Users",
        "Students",
        "Current enrolled students accessing their academic information",
        "High"
    )

    scope.add_in_scope_item(
        "Users",
        "Teachers", 
        "Faculty members managing grades and academic records",
        "High"
    )

    scope.add_in_scope_item(
        "Users",
        "Parents",
        "Parents/guardians viewing their children's academic progress",
        "Medium"
    )

    # Define platform scope
    scope.add_in_scope_item(
        "Platforms",
        "Web Application",
        "Responsive web application supporting modern browsers (Chrome, Firefox, Safari, Edge)",
        "Critical"
    )

    # Define features explicitly out of scope
    scope.add_out_of_scope_item(
        "Features",
        "Financial Management",
        "Fee collection and financial tracking will be handled by existing systems"
    )

    scope.add_out_of_scope_item(
        "Features", 
        "Course Scheduling",
        "Timetabling and room booking is complex and will be addressed in Phase 2"
    )

    scope.add_out_of_scope_item(
        "Features",
        "Advanced Analytics",
        "Complex reporting and analytics require more development time than available"
    )

    # Define platforms out of scope
    scope.add_out_of_scope_item(
        "Platforms",
        "Mobile Applications",
        "Native mobile apps require additional development expertise and time"
    )

    # Define future scope items
    scope.add_future_scope_item(
        "Features",
        "Course Scheduling",
        "Automated timetabling and room booking system with conflict detection",
        "Phase 2"
    )

    scope.add_future_scope_item(
        "Features",
        "Communication Tools",
        "Integrated messaging system for teacher-parent-student communication",
        "Phase 2"
    )

    scope.add_future_scope_item(
        "Platforms",
        "Mobile Applications",
        "Native iOS and Android applications with offline capability",
        "Phase 3"
    )

    # Add project assumptions
    scope.add_assumption("School will provide student and staff data in CSV format for initial import")
    scope.add_assumption("IT department will provide hosting infrastructure and database server")
    scope.add_assumption("Teachers are comfortable using web-based applications")
    scope.add_assumption("Internet connectivity is reliable in all classrooms")

    # Add project constraints
    scope.add_constraint("Budget limited to $85,000 for Phase 1 development")
    scope.add_constraint("Must be completed before start of next academic year (6 months)")
    scope.add_constraint("Must comply with student privacy regulations")
    scope.add_constraint("Development team has 2 developers available part-time")

    # Add dependencies
    scope.add_dependency("Student information system data export from legacy system", "External")
    scope.add_dependency("Single sign-on integration with school's Active Directory", "Technical")
    scope.add_dependency("Approval of user interface designs by school administration", "Internal")

    # Generate and display scope document
    scope_document = scope.generate_scope_document()
    print(scope_document)

    # Validate scope for potential issues
    warnings = scope.validate_scope_coherence()
    if warnings:
        print("\nSCOPE VALIDATION WARNINGS:")
        print("-" * 27)
        for warning in warnings:
            print(f"⚠ {warning}")
    else:
        print("\n✅ Scope definition appears coherent with no conflicts detected")

    return scope

# Run demonstration
if __name__ == "__main__":
    project_scope = demonstrate_scope_definition()

---

Practice tasks

Task 1: Stakeholder analysis exercise

Choose a software project idea relevant to your school or community (e.g., library management system, sports club management, tutoring platform). Complete a stakeholder analysis:

1. Identify stakeholders: List at least 6 different stakeholder groups who would be affected by or interested in your project

2. Assess influence and interest: Create a stakeholder priority matrix categorizing each group

3. Conduct mock interviews: Write 5 interview questions and provide realistic responses for your highest priority stakeholder group

4. Document needs: Use the StakeholderAnalysis class to record and organize stakeholder requirements

Expected outcome: A structured stakeholder analysis with clear requirements traceability.

Task 2: Financial feasibility assessment

Using the same project idea from Task 1, perform a comprehensive financial feasibility analysis:

1. Estimate development costs: Include personnel, tools, infrastructure, and any third-party services

2. Project operational costs: Calculate ongoing hosting, maintenance, and support costs

3. Quantify benefits: Identify specific financial benefits (cost savings, efficiency gains, revenue increases)

4. Calculate ROI: Use the FinancialFeasibilityAnalysis class to determine project viability

5. Risk assessment: Identify financial risks and how they might impact the analysis

Expected outcome: A complete financial feasibility report with ROI calculation and risk assessment.

Task 3: Requirements specification

For your chosen project, create detailed functional and non-functional requirements:

1. Functional requirements: Document at least 5 functional requirements with clear acceptance criteria and test scenarios

2. Non-functional requirements: Specify measurable performance, security, and usability requirements

3. Data model: Define the main entities, their attributes, and relationships using the data structure analysis framework

4. Scope definition: Create a comprehensive scope document clearly defining what is in scope, out of scope, and planned for future phases

Expected outcome: A complete requirements specification document ready for development planning.

Sample solution framework

Here’s a framework you can adapt for any project:

# Task completion template
def complete_requirements_analysis(project_name):
    """Template for completing comprehensive requirements analysis."""

    # Step 1: Stakeholder Analysis
    stakeholder_analysis = StakeholderAnalysis()
    # Add your stakeholders here...

    # Step 2: Financial Analysis  
    financial_analysis = FinancialFeasibilityAnalysis(project_name, 6)
    # Add your costs and benefits here...

    # Step 3: Requirements Documentation
    functional_reqs = []
    non_functional_reqs = []
    # Document your requirements here...

    # Step 4: Data Structure Analysis
    data_analysis = DataStructureAnalysis(project_name)
    # Define your entities here...

    # Step 5: Scope Definition
    scope = ScopeDefinition(project_name, "Phase 1")
    # Define your scope boundaries here...

    return {
        'stakeholders': stakeholder_analysis,
        'financial': financial_analysis,
        'functional_reqs': functional_reqs,
        'non_functional_reqs': non_functional_reqs,
        'data_model': data_analysis,
        'scope': scope
    }

Use this template to structure your analysis and ensure you address all aspects of requirements and feasibility assessment.

---

Key takeaways

This section introduced systematic approaches to requirements analysis and feasibility assessment:

Requirements Analysis Process:

• Stakeholder-centered approach: Understanding who will be affected by and benefit from the solution

• Evidence-based validation: Using research and data to confirm assumptions about needs and problems

• Structured documentation: Recording requirements in specific, measurable, achievable terms

• Traceability: Linking requirements back to stakeholder needs and forward to design decisions

Feasibility Assessment Framework:

• Financial viability: Comprehensive cost-benefit analysis with ROI calculations

• Scheduling realism: Honest assessment of timeline constraints and resource availability

• Technical feasibility: Evaluation of whether required capabilities can be implemented

• Risk awareness: Identifying and planning for potential obstacles and complications

Requirements Classification:

• Functional requirements: What the system must do, with clear acceptance criteria and test scenarios

• Non-functional requirements: How the system should perform, with measurable quality attributes

• Data requirements: Appropriate structures and types based on usage patterns and volume

• Scope boundaries: Clear definition of what is included, excluded, and planned for future phases

Next Steps: In Section 23.2, we’ll explore ideation and modeling tools that help transform these requirements into concrete solution designs and implementation plans.