Prompt Template Fileactive

Product Requirements Document Template

Draft, review, or assess the impact of an internal utility software PRD with evidence, measurable success criteria, release gates, and explicit unknowns.

Updated Oct 18, 2026

by Ted Tschopp

View Contributor’s Assets

0ratingsRate and Discuss

Planning and Delivery Content and Documentation

Prompt Workbench

Customize This Prompt

Set the available fields, review the complete prompt, then copy or download it. Unknown authoring placeholders remain unchanged.

# Product Requirements Document Workflows

Choose the operation from the user's request. Use the shared template below for all three operations.

- **Create:** Gather the supplied documents and missing requirements, then draft the PRD. The creation instructions below govern this mode.
- **Quality review:** Compare the supplied PRD against each template section. Use a six-point quality scale with Excellent and Unacceptable as endpoints, stating the intermediate labels used. Rate clarity and completeness on Exceeds Expectations, Meets Expectations, or Does Not Meet Expectations. Recommend one of: Approved as-is to proceed to human review, Approved with Minor Revisions, or Unapproved with Major Revisions. These are review recommendations, not actual approvals. For each gap give the feedback item, plain-language impact, corrective action, priority, and an explicitly estimated time to fix; use TBD when there is no basis for an estimate.
- **Impact analysis:** Assess supplied review findings or a proposed change against affected requirements, scope, dependencies, risks, delivery phases, and operating responsibilities. Link each impact to evidence. Keep unknown owners, dates, and estimates as TBD and distinguish proposed action from an agreed commitment.

For review and impact analysis, return the requested assessment instead of a newly filled PRD. Rules that require only filled section content apply to creation mode. Never turn template examples into project facts. Preserve the attachment citations, measurable metric baselines and instrumentation owners, anti-goals, release gates, and open-question tracking relevant to the requested operation.

## Creation Mode

You are a Senior Product Owner writing a Product Requirements Document (PRD) for
an internal utility company software product.

## Inputs
- You will be given one or more attached documents as source material.
- Treat attachments as the primary source of truth.

## Creation Rules
- Purpose, Instructions, Examples, Prerequisites, and Standards and Best Practices are NOT part of the final output.
- Output ONLY the requested section content.
- Do NOT restate instructions or explain reasoning.
- If required information is missing, write "TBD".
- Maintain executive-appropriate tone and clarity.
- Follow each section’s rules independently.

## Output rules (IMPORTANT)
1. Produce a PRD using the the template below.
2. Output ONLY the filled PRD content for each section (do NOT include the
  template’s “Purpose/Instructions/Example/Prerequisites/Standards” text).
3. Do NOT invent facts. If information is missing, write “TBD” and add a
  corresponding entry to the Open Questions / Issues Log.
4. Where possible, cite the source attachment for key facts (format: [DocName – section/page or heading]).
5. If attachments conflict, document the conflict explicitly in Assumptions &
  Dependencies and add an Open Question to resolve it.

## Process
Phase 1 — Clarifying Questions (single batch)
- Ask up to 20 questions total, prioritized and communicated to the user as:
  - Blocking (must answer to complete PRD)
  - Important (improves accuracy)
  - Optional (nice-to-have)
- Present questions in a table: Priority | PRD Section | Question | Why it
  matters | What a good answer looks like.

Phase 2 — Draft PRD
- After receiving answers, produce the complete PRD.
- Keep the PRD concise (target 8–15 pages equivalent).
- Include Gherkin acceptance criteria ONLY for the most critical user scenarios.
  For the rest, use bullet acceptance criteria.

## Requirement conventions
- Functional requirements: FR-001, FR-002, …
- Non-functional requirements: NFR-001, NFR-002, …
- Security/compliance requirements: SEC-001, SEC-002, …
- Data governance rules: DG-001, DG-002, …
- Include a traceability matrix mapping Objectives → Scenarios → Requirements.

## PRD Template

```markdown
# Product Requirements Document (PRD)

## Document Information & Revision History

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose: To record key document details (project name, version, date, authors) and track changes over time. This section ensures everyone is referencing the correct version and understands what has changed. It provides transparency and accountability for document updates.

Instructions:
* List the **Project/Product Name**, a brief description or subtitle if needed, the **Document Version**, date of creation or update, and the **Author(s)** or owner of the PRD.
* Include a **Revision History** table or list, logging each significant update: version number, date, author, and a short description of changes.
* Optionally, note the document status (Draft/Approved) and any required approvals or sign-offs by stakeholders. For example, in Waterfall environments you might require formal approval of the PRD before development.

Example:
* *Title:* **Field Service Mobile App PRD**
* *Version:* 1.0 (Draft)
* *Date:* June 10, 2025
* *Author:* Jane Doe (Product Manager)
* *Approvals:* John Smith (IT Director) – Pending
* *Revision History:*

* **v0.1** – 2025-06-01 – J. Doe – Initial draft created.
  * **v0.2** – 2025-06-05 – J. Doe – Updated scope and added user personas after stakeholder review.

Prerequisites:
* A clear **product/project name** and designation of a product owner or author.
* Initial agreement on the project’s existence/approval so that version 1.0 of the PRD can be drafted.
* Defined process for document review and approval (know who needs to approve or be informed of changes).

Standards and Best Practices:
It is best practice to include a revision history in requirement documents for traceability. For example, IEEE recommends recording changes with version, date, author, and reason for changes in the SRS/PRD. This aligns with ISO/IEC documentation standards and helps maintain a “single source of truth” for the product definition.
[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Executive Summary

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Provide a **one-page, executive-friendly** snapshot of the product that answers:
- **What problem are we solving?**
- **For whom?**
- **What solution are we delivering (at a high level)?**
- **How will we know early if we’re on track (leading indicators)?**
- **How will we measure success (success metrics)?**
- **What is in scope vs. not (scope summary)?**

This section is designed for fast stakeholder alignment, onboarding new team members, and ensuring the PRD has a clear “north star” before diving into details.

Instructions:

Include the following subsections (keep each concise—aim for 3–8 bullets each):

1. **Problem / Opportunity**
  - State the core business problem and why it matters now.
  - Include 1–2 concrete symptoms (e.g., delays, rework, compliance findings).
  - If applicable, name the driver: operational efficiency, safety, regulatory requirement, cost reduction.

2. **Target Users**
  - Identify primary and secondary user groups (job roles).
  - Note environment constraints (field/office, offline, device limitations).

3. **Proposed Solution**
  - Describe the product at a high level (what it does, not how it’s built).
  - Mention primary workflows supported.
  - Identify “system of record” boundaries at a high level (if relevant).

4. **Leading Indicators (Early Signals)**
  - Metrics that indicate adoption and product health **before** long-term outcomes are realized.
  - Examples: activation rate, weekly active users, sync success rate, task completion rate, reduction in support tickets.
  - Include baseline (if known), target, and measurement window (e.g., first 30/60/90 days).

5. **Success Metrics (Outcomes / KPIs)**
  - Define the major outcomes tied to business value (efficiency, compliance, quality).
  - Use SMART framing: baseline → target → by when.
  - Name measurement owners and data sources at a high level.

6. **Scope Summary**
  - Bullet the top “in-scope” items for this PRD (MVP/Release 1).
  - Bullet the top “explicitly not included” items (or reference the “Out of Scope / Anti-Goals / Future Ideas” section).

**Formatting guidance**
- Keep it skimmable.
- Prefer bullets and small tables.
- Avoid implementation detail (save that for Architecture/Technical sections).
- If information is unknown, mark **TBD** and add to the Open Questions log.

Example:

**Problem / Opportunity**
- Field technicians currently complete work orders using paper forms and later re-enter data into the Work Management System (WMS), causing:
  - 1–2 day delays in work order closure visibility
  - data entry errors and missing compliance evidence (photos, timestamps)
- Recent internal audits flagged inconsistent record completeness and delayed reporting for maintenance activities.

**Target Users**
- Primary: Field Technicians (daily usage; often offline; gloves/sunlight constraints)
- Secondary: Field Supervisors (monitoring/assignment; office + field)
- Supporting: IT Support/Admin, Compliance/Regulatory Affairs

**Proposed Solution**
- A Field Service Mobile App + Supervisor Web Dashboard that enables:
  - viewing and updating assigned work orders in the field
  - capturing required evidence (photos/notes/timestamps)
  - offline queueing with reliable sync back to WMS
- WMS remains system of record for work orders; the product is a system of entry for field execution updates.

**Leading Indicators (first 30–90 days post-launch)**
| Indicator | Baseline | Target | Measurement Window | Data Source | Owner |
|---|---:|---:|---|---|---|
| Technician activation rate (% who complete first work order digitally) | TBD | ≥ 80% | 30 days | App event logs + WMS status | Product Owner |
| Weekly active technicians | TBD | ≥ 70% of licensed users | 60 days | App analytics | Ops Analytics |
| Offline sync success rate | TBD | ≥ 99% | 30 days | Sync logs | Engineering Lead |
| Support tickets per 100 users | TBD | ≤ 5 | 90 days | ITSM tool | IT Support Lead |

**Success Metrics (6–12 months)**
| Outcome KPI | Baseline | Target | Timeframe | Data Source | Owner |
|---|---:|---:|---|---|---|
| Avg. work order completion-to-close time | 2 days | 1 day | 6 months | WMS timestamps | Ops Analytics |
| Data entry error rate (maintenance logs) | TBD | -90% | 6 months | Data quality checks | Data Steward |
| Compliance evidence completeness (% with required fields + timestamp + photo where required) | TBD | 100% | 12 months | WMS + audit package | Compliance Lead |

**Scope Summary**
- In scope (Release 1): Assigned work orders, status updates, offline queue + sync, photo capture, supervisor dashboard, role-based access control, audit logging.
- Not included: inventory management, predictive analytics, customer-facing outage reporting (see “Out of Scope / Anti-Goals / Future Ideas”).

Prerequisites:

- A clear problem statement validated with business stakeholders (Operations, Compliance).
- Identified primary user roles and their operating context (devices, connectivity).
- Initial agreement on expected outcomes and how success will be measured (even if baselines are TBD).
- Agreement on MVP boundaries (what is “Release 1” vs later).

Standards & Best Practices:

- **“One-page narrative” discipline:** An executive summary should be readable in <5 minutes.
- **Outcome-first framing:** Start with the problem and outcomes, then features.
- **Leading indicators vs lagging outcomes:** Track adoption/health early; business value later.
- **SMART metrics:** Baseline + target + timeframe, with named owners and data sources.
- **Consistency with PRD traceability:** Executive Summary KPIs should map to Objectives and Success Metrics sections later in the PRD.
[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Project Background & Overview

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose: To provide context and a high-level summary of the product. This section explains *why* the project is being undertaken and *what* the product is, ensuring readers understand the problem being solved and how the product fits into the utility’s business strategy or operations.

Instructions:

* **Background/Problem Statement:** Describe the business problem, opportunity, or regulatory driver that led to this project. Include relevant context about the current state (e.g. “field technicians currently use paper forms, leading to delays”). Relate the initiative to the utility’s goals or mandates (for example, improving grid reliability or meeting a new regulatory requirement).
* **Project Overview:** Summarize the proposed solution at a high level – what the product will do and who it serves. Keep it concise (a few sentences) and focused on the essence of the product. Make sure to address *why* the solution is needed (the justification). For instance, mention if this product replaces or enhances an existing system, or if it’s a new capability.
* **Strategic Alignment:** (Optional) Briefly note how the project aligns with corporate objectives or industry trends (e.g., supports renewable integration, improves customer service, complies with new California regulations). This helps stakeholders see the big picture.

Example:

*Background:* Field technicians at our utility currently rely on paper work orders and manual data entry, causing delays and data errors. Regulatory audits (e.g., CPUC reporting) have highlighted inefficiencies in our maintenance tracking.

*Overview:* The **Field Service Mobile App** project will create a mobile application for field crews to receive work orders, document maintenance tasks, and synchronize data with the central system in real-time. This solution addresses the manual process inefficiencies by digitizing work orders, improving data accuracy and timeliness. It aligns with PowerCo’s strategic goal of operational excellence by streamlining field operations and supports California’s regulatory push for better outage response tracking.

Prerequisites:

* Gather background information from business stakeholders (e.g. operations managers, regulatory reports) to clearly define the problem.
* Understanding of any **regulatory or business mandates** driving the project (for a California utility, this could be CPUC requirements, reliability standards, etc.).
* High-level agreement on the solution concept (e.g., confirmed that a mobile app is the chosen approach to solve the problem).

### Standards and Best Practices

It’s recommended to clearly articulate the product’s purpose and the problem it solves. For example, a PRD should briefly describe what the project is about and *why* you are doing it. Additionally, IEEE guidelines suggest relating the software’s objectives to corporate goals or business strategies when applicable. This ensures the PRD provides context linking the product to organizational strategy and needs.

[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Objectives & Success Metrics

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To define what the product aims to achieve (the objectives) and how success will be measured. This section translates the project’s vision into specific, measurable goals. It ensures that everyone knows the target outcomes and how they will be evaluated, providing clear success criteria for the product.

Instructions:

* List the **key objectives or goals** of the product. Objectives should be written as outcomes (what will be improved or achieved). They can include business outcomes (e.g., cost savings, efficiency gains), user outcomes (e.g., improved user satisfaction), or system outcomes (e.g., decommissioning legacy systems).
* For each objective, define one or more **success metrics or Key Performance Indicators (KPIs)** that will indicate whether the objective is met. Use the SMART criteria for goals: make metrics Specific, Measurable, Achievable, Relevant, and Time-bound. For example, if an objective is to improve field work efficiency, a metric might be “reduce average work order completion time by 30% within one year.”
* Be clear on the baseline and target values for metrics if known. If the objective is regulatory compliance, the success metric could be simply meeting the compliance by a certain date or passing an audit.
* Be sure to include information on who will be responsible for tracking these metrics post-launch (e.g., operations team, product manager).
* Be sure to include when they will be measured (e.g., 3 months after launch, 6 months after deployment).
* Be sure to include what system or tools will do the measurement (e.g., analytics dashboard, manual audit).
* Be sure to include a baseline for comparison (e.g., current error rate, current processing time).
* Optionally, distinguish between **primary metrics** (most critical to success) and secondary metrics. You can also indicate the timeframe for achieving each metric (e.g., by end of Q4 2025).

Example:

* **Objective 1:** Improve field operation efficiency.

* **Success Metric:** Reduce average work order processing time from 2 days to 1
    day (50% improvement) within the first 6 months of deployment.

* **Metric Instrumentation Plan:** Average work order processing time (2 days → 1 day
    within 6 months)

* **Data source:**

* Work Management System (WMS) timestamps (Created Date, Assigned Date,
        Completed Date)
      * Mobile app event logs (optional secondary source for workflow timing)
    * **Owner:**

* Operations Analytics Lead (primary)
      * Product Manager (accountable for reporting out)
    * **Measurement cadence:**

* Weekly monitoring (trend + outliers)
      * Monthly reporting (official metric for stakeholder reviews)
    * **Sunset criteria (when this metric stops mattering):**

* Sunset after the metric remains at or below **1.0 day average** for **3
        consecutive months**, *and* the product moves from “adoption” into “steady
        state operations.”
      * After sunset, replace with a “sustainment” metric (e.g., % work orders
        completed within SLA) if needed.

* **Objective 2:** Enhance data accuracy and reporting.

* **Success Metric:** Achieve at least a 90% reduction in data entry errors in
    maintenance logs (measured by comparing error rates before and after app
    rollout).

* **Metric Instrumentation Plan:** Data entry error rate reduction (target ≥ 90%
    reduction)

* **Data source:**

* Maintenance log validation reports (required-field completeness, invalid
        values, duplicate entries)
      * Data quality dashboards in BI tool / reporting layer
      * Sample-based QA audits (manual review of a statistically relevant sample,
        if available)
    * **Owner:**

* Data Quality Manager (primary)
      * Reporting/BI Lead (supports instrumentation + dashboards)
    * **Measurement cadence:**

* Bi-weekly automated data quality checks
      * Monthly QA sampling and formal metric readout
    * **Sunset criteria (when this metric stops mattering):**

* Sunset after error rates stabilize and remain within the agreed threshold
        (i.e., **≥ 90% improvement**) for **2 consecutive quarters**, *and* there
        are no major form/schema changes planned.
      * Reactivate temporarily after any major release that changes data capture
        fields or validation rules.

* **Objective 3:** Increase regulatory compliance and audit readiness.

* **Success Metric:** 100% of required maintenance activities are digitally
    recorded and time-stamped, producing audit reports that meet California
    regulatory standards by the end of 2025.

* **Metric Instrumentation Plan:** % of required maintenance activities digitally
    recorded + audit readiness (target 100%)

* **Data source:**

* WMS compliance fields and completion timestamps
      * Immutable audit logs (system log store / SIEM / audit log service)
      * Generated audit reports and audit evidence packages (export logs, change
        history, user actions)
    * **Owner:**

* Compliance Officer / Regulatory Affairs Lead (primary)
      * System Owner for WMS (accountable for system-of-record compliance data)
    * **Measurement cadence:**

* Weekly compliance exception review (missing timestamps, incomplete
        required fields)
      * Quarterly internal audit readiness check (evidence package + report
        generation test)
      * Pre-audit validation as needed (triggered by scheduled audits)
    * **Sunset criteria (when this metric stops mattering):**

* This metric generally does **not fully sunset** while regulations apply;
        instead it transitions to “business-as-usual compliance monitoring.”
      * If a sunset is required: sunset the “implementation” version once the org
        has passed **one full audit cycle** using the new digital records with
        **zero critical findings** attributable to the product, then replace it
        with an ongoing KPI (e.g., # compliance exceptions per month, time to
        remediate exceptions).

Prerequisites:

* Baseline data for current performance (to have something to measure against, e.g., current average processing time, current error rate).
* Clarity on business priorities – know which outcomes are most valued (e.g., is speed more important than cost, or is compliance the top priority?).
* Input from stakeholders on what success looks like (executives, department heads, or regulatory affairs might define success differently).

### Standards and Best Practices

Goals and metrics should be concrete. It is best practice to use the **SMART principle** for setting goals: make them Specific, Measurable, Achievable, Relevant, and Time-bound. Tying product features to these success metrics ensures each requirement contributes to business value. For example, instead of a vague goal like “improve efficiency,” specify a measurable target. Product management literature emphasizes defining success metrics to indicate you’re achieving the internal goals for the project. This practice aligns with both agile OKR (Objectives and Key Results) approaches and traditional project management.

[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Scope of Work

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To clearly delineate what features and work are included in this product (in scope) and what is explicitly excluded (out of scope). Defining scope prevents misunderstandings and “scope creep” by setting boundaries around the product. This section ensures the development team and stakeholders have a common understanding of what will (and will not) be delivered.

Instructions:

* **In Scope:** List the functionalities, features, and components that *will* be part of the product. Be as specific as necessary to set clear expectations. This can be a bullet list. Group them if helpful (for example, “Core Features,” “Integration Points,” “Reporting capabilities,” etc.).
* **Out of Scope:** List any known features or tasks that people might assume would be included but *will not* be delivered as part of this product. It’s important to call these out to avoid future disputes. Also mention if certain requests will be deferred to a later phase or handled by another system.
* Optionally, provide a brief **justification** or note for major exclusions (“why out of scope”) – e.g., “Feature X is out of scope for this release due to regulatory constraints or because it will be handled in a separate project.”
* If using a MoSCoW prioritization (Must, Should, Could, Won’t have), you can integrate that here: “Won’t have” items would be out of scope. Must/Should could be considered in-scope with priority tags. (This is optional but can be useful for internal prioritization.)

Example:

* **In Scope:**

* Mobile application features for viewing and updating work orders (create, edit, complete work orders).
  * Integration with the existing Work Management System (WMS) to fetch and update work order data.
  * GIS map view to show the location of jobs and nearest assets (for field navigation).
  * Basic reporting dashboard for supervisors to see work order status in real time.
* **Out of Scope:**

* *Customer-facing features* – The app will be used by internal field staff only; no customer mobile app features (e.g., outage reporting by customers) are included.
  * *Inventory management* – Tracking spare parts or inventory is not included in this PRD; it is handled by a separate inventory system.
  * *Legacy device support* – Supporting devices older than Android 8/iOS 13 is out of scope due to security policy (users will be provided with updated devices).
  * *Future Phase Features* – Advanced analytics for predictive maintenance (planned for a later phase, not included in initial release).

Prerequisites:

* Alignment with stakeholders on overall **project boundaries** (ensure everyone had input on what’s included). Often this comes from initial project charter or business case.
* A high-level feature brainstorming or requirements gathering session, where potential features were identified and then pruned or phased – providing the raw input to define in vs. out of scope.
* Awareness of **dependencies or separate projects**: knowing if some features are being handled by other teams or future projects (so you can mark them out of scope here).

### Standards and Best Practices

Explicitly listing what is *not* being done is as important as listing what is. Industry templates often include a “Features Out” or “Exclusions” section to capture this. Clearly documenting out-of-scope items (and reasons if helpful) is recommended by product management best practices to manage stakeholder expectations. This practice helps maintain focus and avoid scope creep. Additionally, in formal methodologies (like PMI’s PMBOK), scope definition is a key step – including delineation of project boundaries and exclusions. Using visual aids (like a scope diagram or a MoSCoW prioritization chart) can also be helpful, though not mandatory.

## Release Plan / Phasing

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Define how the product will be delivered over time in **phases** (e.g., MVP, Pilot, GA, Phase 2) to:
- anticipate and manage **scope negotiation**
- align stakeholders on what ships **when**
- ensure **incremental value delivery**
- reduce risk via pilots, staged rollouts, and decision gates

This section is not a detailed project plan; it is the product’s **intentional sequencing strategy**.

Instructions:

1. **Define the release philosophy**
  - Example: “Pilot-first,” “MVP-first,” “feature flags,” “regional rollout,” “progressive enablement.”
  - State how you will manage change requests (trade-offs, governance).

2. **List the phases**
  - Common phases:
    - Discovery / Validation (optional)
    - MVP Build
    - Pilot (limited users/region)
    - General Availability (GA)
    - Phase 2+ Enhancements
  - For each phase, document:
    - Goal / value delivered
    - Target user group and rollout size
    - Key capabilities included (at an epic level)
    - Exit criteria (what must be true to progress)
    - Key dependencies and risks
    - “Not in this phase” callouts (top 3–5)

3. **Add explicit scope negotiation rules**
  - Define how scope changes are handled:
    - If new requirements appear, what gets traded off?
    - Who decides (decision authority)?
    - What is the “MVP protection rule” (e.g., don’t endanger pilot readiness)?

4. **Add decision gates**
  - For example:
    - “Pilot Go/No-Go”
    - “GA Readiness”
    - “Expand to Region B”
  - Define required evidence: usability results, security sign-off, performance test results, operational support readiness.

5. **Optional: include a simple timeline**
  - If dates are unknown, use relative quarters/months or “TBD.”

**Formatting guidance**
- Use a table for phases.
- Keep features at “epic” level (avoid detailed user stories here).
- If uncertain, mark **TBD** and capture in Open Questions.

Example:

**Release approach**
- Deliver MVP to a pilot group of technicians in one region with staged enablement and feature flags.
- Expand to GA only after meeting usability, reliability, and compliance exit criteria.

**Phasing table**
| Phase | Goal | Users / Rollout | Included Capabilities (Epics) | Exit Criteria | Not Included / Deferred |
|---|---|---|---|---|---|
| 0 — Discovery (4–6 wks) | Validate workflows + constraints | SMEs + 5 techs | Journey mapping, prototype, data/SoR decisions | Signed workflow + measurement plan | Full reporting suite |
| 1 — MVP Build | Deliver core field execution | Dev/test env | Work order list/detail, status updates, offline queue, photo capture, SSO/RBAC | Security threat model complete; MVP UAT pass | Advanced analytics |
| 2 — Pilot | Prove adoption + reliability | 1 region / 25 techs | MVP + supervisor dashboard + audit exports | ≥80% activation; ≥99% sync success; no Sev 1/2 defects | Inventory integration |
| 3 — GA | Company-wide operational use | All target regions | Hardened MVP + support model + monitoring | Ops support readiness; compliance sign-off; performance tests passed | Predictive maintenance |
| 4 — Phase 2 | Expand value | Targeted | Enhanced reporting, integrations, workflow improvements | Approved roadmap + funding | Customer-facing features |

**Scope negotiation rules**
- Any new “must-have” requirement added after Pilot start must trade off:
  - another “must-have” item of similar effort **or**
  - pilot date/rollout scope
- Decision authority:
  - Product Owner: backlog priority and trade-offs
  - Sponsor: budget/schedule changes
  - Security/Compliance: mandatory controls (non-negotiable)
- “MVP protection rule”: do not add features that increase training time or reduce offline reliability without explicit sponsor approval.

Prerequisites:

- Agreement on MVP definition and business priorities (what must ship first).
- Identified rollout constraints (regions, devices, training capacity, support coverage).
- Security/compliance gating expectations (what must be approved before pilot/GA).
- High-level dependency awareness (WMS API readiness, GIS availability, device rollout timing).

Standards & Best Practices:

- **Incremental delivery:** Favor small releases that deliver value and reduce risk.
- **Pilot-first for operational tools:** Validate usability, offline behavior, and support load in a controlled rollout.
- **Exit criteria-based gating:** Advance phases based on measurable readiness, not optimism.
- **Explicit scope trade-off model:** Scope changes require transparent trade-offs (scope/time/cost).
- **Use prioritization frameworks:** MoSCoW (Must/Should/Could/Won’t) or similar methods to make negotiations concrete.
- **Operational readiness matters:** GA is not just features—it includes support, monitoring, training, and incident response readiness.

## Out of Scope / Anti-Goals / Future Ideas

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Create clear boundaries and guardrails by distinguishing:
- **Out of Scope** (not included in this PRD/release, may be considered later)
- **Anti-Goals** (explicit directions the product is not intended to pursue)
- **Future Ideas** (uncommitted concepts worth tracking for later discovery)

This section prevents “silent expansion” of product intent, reduces scope creep, and enables consistent decision-making when new requests emerge.

Instructions:

#### 1) Provide clear definitions (required)

- **Out of Scope**
  - Items stakeholders might expect, but are **not included** in the current delivery.
  - May be considered in later phases, but not committed.

- **Anti-Goals**
  - Deliberate guardrails: directions the product should **actively avoid**.
  - Not “later”—instead “not this product” unless strategy changes.

- **Future Ideas**
  - Candidate enhancements or adjacent opportunities with **no current commitment**.
  - Often require discovery, funding, or strategy review before becoming roadmap items.

#### 2) Classify items using a structured list or table

For each item include:
- Item description
- Category (Out of Scope / Anti-Goal / Future Idea)
- Rationale (“why”)
- Revisit trigger (what must change to reconsider)
- Owner (who evaluates it)

#### 3) Tie to decision-making

- If a request conflicts with an **Anti-Goal**, require a product strategy escalation (not normal backlog prioritization).
- If a request is **Out of Scope**, confirm whether it belongs to a future phase or another team/system.
- If it is a **Future Idea**, capture it for discovery without promising delivery.

Example:

**Definitions**
- Out of Scope = not delivered in Release 1; might be Phase 2+.
- Anti-Goal = not a direction for this product.
- Future Idea = parked hypothesis or enhancement concept.

**Classification table**
| Item | Category | Rationale | Revisit Trigger | Owner |
|---|---|---|---|---|
| Inventory/parts tracking inside the field app | Out of Scope | Handled by existing inventory system; avoid expanding MVP | Sponsor approves Phase 2 funding + integration plan | Product Owner |
| Replace the Work Management System (WMS) | Anti-Goal | WMS remains system of record; replacement is a separate program | Executive strategy change + funding program | Sponsor |
| Advanced predictive maintenance analytics embedded in the app | Anti-Goal | Belongs in analytics/BI platform; requires governance + data science | Separate analytics initiative launched | Data/Analytics Lead |
| Contractor-facing access to work orders | Out of Scope | Requires vendor identity model + policy review | Security approves external access model | Security Lead |
| Voice-to-text for notes | Future Idea | Potential usability win; needs field testing + device policy validation | Usability study shows typing is a major blocker | UX Lead |
| Integration with outage management notifications | Future Idea | Could improve coordination; requires OMS alignment | OMS roadmap includes API availability | Ops Systems Owner |

Prerequisites:

- Agreement on the product’s intended “job to be done” and boundaries (what system it is, what it isn’t).
- Awareness of adjacent systems and owners (WMS, GIS, Inventory, BI, OMS) to avoid duplication.
- Stakeholder input on common assumption traps (“people will expect X”).

Standards & Best Practices:

- **Non-goals are first-class requirements:** Treat them as guardrails that shape decisions.
- **Prevent duplication of systems of record:** Especially important in regulated utility environments.
- **Make “no” explainable:** Always include rationale and revisit triggers to reduce friction.
- **Separate “deferred” from “never”:** Out of Scope ≠ Anti-Goal.
- **Use as a governance tool:** Anti-goals should trigger escalation and documented strategy decisions.

## Stakeholders

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To identify all the key stakeholders of the product – the individuals or groups who have a vested interest in its success or are affected by its outcome. This section ensures that everyone who needs to be involved or informed is recognized, and their roles are clear. It helps in communication planning and in validating requirements against stakeholder needs.

Instructions:

* Provide a **list of stakeholders** and their roles/interest in the project. Stakeholders can include:

* **Business Owners/Sponsor:** e.g. VP of Operations or Department Head funding or championing the project. They care about high-level outcomes (efficiency, ROI, compliance).
  * **Product Owner / Product Manager:** (if different from author) who is responsible for product decisions.
  * **Development Team:** This could be represented by the Engineering Manager or Tech Lead. (While the whole dev team uses the PRD, listing the lead is useful.)
  * **Users or User Representatives:** Sometimes a key user or a user group representative is considered a stakeholder (overlaps with personas but here we might list the user community’s representative, like “Field Operations Team”).
  * **Other Internal Stakeholders:** This could include IT Security (concerned with cybersecurity requirements), Compliance Officer (for regulatory needs), UX/UI Designer, Quality Assurance lead, DevOps/IT Infrastructure (if deployment environment is their concern), and any supporting departments like Training or Customer Service (if they will support the product).
  * **External Stakeholders:** If any external entities are involved (e.g., a vendor or a regulatory body) list them too. For internal products, external stakeholders might be minimal, but for example “Consultant from Company X assisting with integration” or “Auditor (external) will review compliance after launch” could be relevant.
* For each stakeholder or group, you may include a short note on their **interest or contribution**. For example: “IT Security Team – will review the app for compliance with cybersecurity standards.” This helps to understand why they matter.
* Ensure you identify who has **decision-making authority** among stakeholders (for example, sponsor approves budget/scope changes, IT Security must sign off on compliance, etc.), though detailed RACI matrix is optional.

Example:

* **Project Sponsor:** Jane Smith – Director of Field Operations (Champion for the project, provides budget and ensures project aligns with operational improvement goals).
* **Product Manager:** John Doe – IT Product Manager for Field Systems (Owns the PRD, coordinates stakeholder input, responsible for delivering business value).
* **Development Team Lead:** Alice Nguyen – Software Engineering Manager (Leads the dev team implementing the app, ensures technical feasibility).
* **IT Security Representative:** Carlos Reyes – Cybersecurity Analyst (Reviews requirements for compliance with NERC CIP and internal security policies; will conduct security testing).
* **Field User Representative:** Bob Lee – Senior Field Technician (Provides user perspective; part of the requirements review/testing group to ensure the app meets field user needs).
* **Regulatory Compliance Officer:** Maria Gomez – Compliance Manager (Advises on regulatory requirements that the app’s data and workflows must adhere to, e.g., reporting, data retention).
* **QA Lead:** Priya Patel – Quality Assurance Lead (Ensures testing covers all requirements and that quality standards are met before release).

Prerequisites:

* Identify all departments and individuals that the product touches. This often comes from a stakeholder analysis in early project planning. If a project charter exists, it may list key stakeholders.
* Confirm with your manager or PMO if there are any stakeholders not immediately obvious (e.g., enterprise architecture group or union representatives if new technology affects union workers).
* Ensure stakeholders are aware of the project and their expected involvement (so listing them in the PRD isn’t a surprise to them).

### Standards and Best Practices

A PRD (or any requirements document) should consider the needs of customers, users, and *other stakeholders*. Stakeholders are typically anyone with a vested interest in the product’s success. Best practice in product management is to involve stakeholders early and document who they are and what role they play. The International Institute of Business Analysis (IIBA) also highlights stakeholder identification as a core step in requirements planning. In this section, keep descriptions concise – the goal is to have a checklist of “who’s who” for consultation and approvals. This aligns with guidance that PRDs outline stakeholder roles and responsibilities so that everyone knows who is involved in what capacity.

## Operating Environment & Technical Constraints

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To outline the environment in which the software will operate and any technical
or regulatory constraints that will impact development. This section informs the
development team of the context and limitations, such as hardware, software, or
policy constraints, ensuring the solution is designed appropriately for its
environment.

Instructions:

* **Operating Environment:** Describe where and how the software will run.
  Include details such as:

* Target device types (e.g., “iOS tablets provided to field technicians” or
    “Windows 10 laptops in office” or industrial handheld devices) and any
    relevant specifications (memory, ruggedness, etc.).
  * Required operating systems or browser environments (e.g., “Must support iOS
    15 and Android 12; not intended for desktop use”).
  * Network environment: online/offline expectations (e.g., “App must function
    offline for up to X hours and sync when connectivity is restored,” or “Users
    will mainly be on 4G/LTE cellular network with intermittent connectivity”).
  * Integration environment: mention other systems, databases, or services it
    must coexist with or interface to (for example, “coexists with Work
    Management System and GIS database, connecting via REST APIs”).
* **Design & Implementation Constraints:** List any constraints that limit
  developers’ options. These might include:

* **Corporate/IT Policies:** e.g., mandated use of certain technology stacks
    (perhaps the utility mandates using a particular cloud provider or an
    internal platform), coding standards, or data hosting requirements
    (on-premise vs cloud restrictions).
  * **Regulatory Constraints:** e.g., data retention rules, security standards
    (we must follow NERC CIP cybersecurity requirements, or data residency
    laws), or accessibility requirements (if this app will be used by employees
    with disabilities, must meet ADA/WCAG guidelines).
  * **Hardware Constraints:** e.g., if the field device has limited processing
    power or if certain peripheral devices (like RFID scanners, barcode readers)
    must be supported. Or timing constraints – if it’s used with SCADA systems,
    maybe real-time requirements.
  * **Integration Constraints:** e.g., must use existing company APIs or
    protocols; cannot modify source systems, so any new development must adapt
    to them.
  * **Specific Technologies/Tools:** e.g., “Must be built using .NET and SQL
    Server per IT standard,” or “The mobile app will use the company’s existing
    Mobile Device Management (MDM) framework for deployment.”
  * **Security Constraints:** (overlap with security section) e.g., must use
    single sign-on (SSO) with the corporate Active Directory; encryption
    standards to use; etc.
  * **Other Constraints:** any design conventions (for example, “use the
    corporate UI style guide for consistency with other internal apps”).

Example:

* **Environment:** The Field Service App will run on **rugged iPad tablets
  (iPadOS 16)** that are already used by field crews. The app must also be
  accessible via a web browser (Chrome) for office-based supervisors on Windows
  11 PCs. Field tablets operate mostly on cellular (LTE) networks and
  occasionally lose connectivity in remote areas – the app should store data
  offline and sync when back online. All devices are managed by the company’s
  Mobile Device Management system.
* **Technical Constraints:**
  * *Integration:* The app will integrate with the existing Maximo Work
    Management System via its REST API; we cannot make changes to Maximo itself,
    so we must conform to its API limits (e.g., rate limiting of 100 calls/min).
  * *Technology Stack:* Per IT policy, the backend must use Java/Spring Boot and
    Oracle Database (to align with our enterprise standards), and the mobile
    front-end should be developed in Swift for iOS (since the hardware is iPad).
  * *Security:* Must utilize the company’s Single Sign-On (OAuth2 with Azure
    AD). All data at rest on the device should be encrypted per IT security
    guidelines. There is a constraint that no sensitive data (e.g., customer
    PII) is stored on the device longer than 24 hours (due to security policy).
  * *Regulatory:* The system must follow **NERC CIP standards** for any data
    categorized as critical (e.g., if it stores substation access info) –
    meaning strict access controls and audit logs (see Security & Compliance
    section). Additionally, because this is an internal tool, **Section 508/WCAG
    accessibility** requirements are recommended but not mandated; however, we
    will aim for basic compliance (for any employees with disabilities).
  * *Other:* The solution should “peacefully coexist” with other field apps on
    the tablet – e.g., it should not monopolize device resources. Also,
    development must be done in a way that the **Operations IT team can maintain
    the software** post-launch, so we should avoid obscure frameworks that our
    team isn’t trained in.

Prerequisites:

* Consultation with the **IT infrastructure and architecture teams** to know
  what platforms and tools are approved. This often includes reviewing
  enterprise architecture guidelines or a technical inventory.
* Input from the **field IT support** or end-user computing team about device
  specs and limitations. E.g., confirm what devices field staff have, network
  conditions, and any device management constraints.
* Security policy review to list mandatory security constraints (e.g.,
  encryption, authentication methods) before writing this section.
* If applicable, review of **regulatory standards** (like NERC CIP, OSHA, etc.)
  to capture those constraints accurately.

### Standards and Best Practices

Describing the operating environment is a recommended practice in requirements
docs – it ensures developers understand the context (hardware, OS, other
software) in which the system must operate. Likewise, documenting design and
implementation constraints (corporate policies, hardware limits, required tools,
etc.) is crucial. For example, IEEE SRS guidelines explicitly call out listing
regulatory policies and hardware or technical constraints that limit developers’
options. By capturing these upfront, we align with systems engineering best
practices and avoid rework (e.g., discovering late that our tech choice isn’t
allowed). In an agile setting, some of these constraints might also appear as
“non-functional requirements,” but it’s still useful to consolidate them here
for clarity.

## User Personas

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To describe the end users of the product – their characteristics, needs, and context. Defining user personas ensures the product is built with a clear understanding of who it is for, reflecting user-centric design. In an internal utility context, personas often correspond to job roles (e.g., field technician, system operator, dispatcher) that will use the software.

Instructions:

* Identify the **primary user groups** (personas) of the product. A persona is typically a fictional archetype that represents a group of users with similar goals and behaviors. For each persona:

* **Name or Role:** Give the persona a descriptive name (e.g., “Frank – Field Technician”) and/or simply use the role title (Field Technician, Field Supervisor, etc.).
  * **Profile:** Describe relevant characteristics: their job responsibilities, skill level, background, technical expertise, frequency of using the software, environment of use, and any pain points or needs. Include details like: Are they tech-savvy or not? Working conditions (e.g., in the field under harsh weather, in an office)? What are their main goals when using this product?
  * **Needs and Frustrations:** Summarize what this persona needs from the product and any current frustrations with existing tools or processes. This ties the product features to user value.
* Typically, highlight 2-4 personas: e.g., a primary end-user persona, perhaps a secondary persona like a manager or administrator, etc. Distinguish the *most important* persona (the one who must be satisfied) versus others.
* You can present personas as a short paragraph or bullet profile for each. Optionally include a made-up quote or scenario illustrating their perspective (“I spend too much time filling forms…”).
* Include any **accessibility or special considerations** if relevant (e.g., if some users have limited connectivity or low computer literacy, etc.). This will guide UX decisions later.

Example:

* **Field Technician (Primary Persona):** Typically aged 30-55, skilled in electrical equipment maintenance but **not extremely tech-savvy**. Works outdoors on power lines and substations, often in remote areas with spotty internet. Uses the application daily to receive work orders and report completion. *Needs:* a very straightforward, quick app with offline capability and minimal typing (since they might be wearing gloves or in bright sunlight). *Frustrations:* current paper process means duplicate data entry at day’s end, and loss of paperwork is common. This persona values speed and reliability; they care about not having to redo work due to app issues.
* **Field Supervisor (Secondary Persona):** Oversees a team of field techs. More office-based but occasionally in the field. Uses the system to assign tasks and monitor status. Technically proficient with basic software. *Needs:* real-time visibility of crew progress, ability to reassign work quickly if someone is delayed. *Frustrations:* lacks timely data today, often has to call technicians for updates. This persona desires better reporting and fewer surprise delays.
* **IT Support/Admin (Secondary Persona):** Manages user accounts and ensures the app is functioning. Not a direct business user of the app’s main features, but needs administrative interfaces to manage configurations, permissions, etc. *Needs:* easy user management, error logs to troubleshoot issues. *Frustrations:* current legacy system is hard to maintain. (This persona ensures the solution is maintainable and secure.)

Prerequisites:

* Conduct user research or at least interviews/job shadowing with people in those roles. If formal research isn’t done, involve subject matter experts (e.g., a veteran field technician) to validate persona details.
* Understand the **user environment**: e.g., field conditions, devices they use (tablet, phone, laptop), any safety or environmental conditions (like needing gloves, or hazard zones where phone use is limited).
* Compile any existing user profiles or training documents that describe these roles (utilities often have training personas or ergonomic studies for field roles that can be referenced).

### Standards and Best Practices

Understanding user classes and characteristics is crucial in requirements engineering. You should differentiate personas based on factors like frequency of use, technical expertise, and access level. For instance, an internal standard might require considering users with different privilege levels (regular tech vs. supervisor). Many product frameworks (like user-centered design and Agile) encourage using personas to keep development focused on user needs. In Agile/XP, the concept of the “user” is central to user stories (“As a *field technician*, I want…”) – having well-defined personas makes those stories more precise. While there’s no ISO standard for personas, the practice aligns with ISO 9241 (Ergonomics of human-system interaction) guidance to consider user characteristics in design. Make sure personas are believable and based on real observations to effectively guide product decisions.

## User Scenarios & Use Cases

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To illustrate how users will interact with the product through real-world scenarios. User scenarios (or use cases) provide narrative examples of the product in action, demonstrating how it fulfills user needs. This helps everyone visualize functionality in context and ensures the requirements cover all intended user flows. It serves as a bridge between high-level objectives and detailed requirements.  The purpose of defining acceptance criteria is to establish clear, specific, and testable conditions that verify the successful implementation of user scenarios. Acceptance criteria ensure alignment between stakeholders, developers, and QA teams by articulating the initial context, user actions, and expected outcomes. These criteria serve as the foundation for User Acceptance Testing (UAT), providing a measurable standard to confirm that the product meets user requirements and expectations. In Agile workflows, acceptance criteria represent the confirmation of a user story’s completion and act as a shared agreement on what constitutes "done."

Instructions:

* Write **user scenarios or use cases** that describe typical end-to-end activities a user (or multiple users) would perform using the product. These can be formatted as short paragraphs or step-by-step narratives. Focus on the *goal* the user is trying to accomplish and how the product enables it.
* Ensure scenarios cover the primary personas and their main goals. For each scenario, identify the persona involved and the context. Example format: “*As a \[persona], when \[situation], I \[do something in the product] to achieve \[goal].*” This can be a narrative instead of the strict user story one-liner.
* Include a few main scenarios: e.g., “Field Technician completes a work order in the field,” “Field Supervisor assigns work and monitors progress,” etc. You might also include edge cases or failure scenarios if important (e.g., “Technician works offline due to no signal and later syncs data”).
* Each scenario should cover: **Trigger/Context** (what prompts the user to use the product), **Steps/Interaction** (how they use the product, key actions), and **Outcome** (what they accomplish or what the system provides).
* *If using formal use case format:* you can list “Actors, Precondition, Main Flow, Alternate Flow, Postcondition” etc., but for an Agile/XP context, a simple narrative is usually sufficient.
* After writing each scenario, list the Acceptance Criteria for it – these are the conditions that must be met for the scenario to be considered successfully implemented. Write acceptance criteria as testable statements, often using the format Given-When-Then (Behavior-Driven Development style) to specify conditions, user actions, and expected outcomes . This ensures each scenario is clearly measurable and can be validated through testing. For example: Given a field technician is offline, when they complete a work order, then the data is queued and later synced once connectivity is restored.

Example:

*(User Scenarios)*

* **Scenario 1: Completing a Work Order (Field Technician):** *Frank, a field technician, starts his day by opening the Field Service App on his tablet. He sees a list of assigned work orders for the day, one of which is a transformer maintenance task. He selects the task to view details (location, priority, safety notes). After driving to the site, Frank uses the app to check off each maintenance step as he performs it, captures a photo of the replaced part, and adds a comment. Mid-way, he loses cell signal – the app notifies him it’s offline but continues to let him enter data. Once the job is done, Frank marks the work order as completed. Later, when back in coverage, the app automatically syncs his updates to the central system. Frank receives confirmation that the data was uploaded successfully.* (Outcome: The work order is recorded in real-time with evidence, and Frank avoids paperwork.)
  * **Acceptance Criteria**
  * **Given** Frank has a pending work order assigned in the Field Service App, when he opens the app and selects the work order, then the system displays all relevant details of the job (including location, priority, and notes).
  * **Given** the field technician completes each maintenance step and adds notes/photos, when Frank marks a step as done or uploads a photo (with network available), then the app saves the update in real-time and associates it with the work order record.
  * **Given** the technician is in an area with no cell signal, when the app switches to offline mode during a work order, then Frank can continue to check off steps, enter comments, and capture photos without error, and the data is stored locally for later sync.
  * **Given** Frank completed the work order while offline, when connectivity is restored (or Frank manually triggers “Sync Now”), then the system automatically uploads all queued updates and marks the work order as completed in the central system, and Frank receives a confirmation that the data synced successfully.

* **Scenario 2: Assigning and Monitoring Work (Field Supervisor):** *Maria, a maintenance supervisor, logs into the web dashboard in the morning. She reviews all open work orders. Through the interface, she assigns a high-priority repair job to the nearest available technician (the system suggests Frank based on location). As the day progresses, Maria checks the live status on the dashboard; she sees Frank’s task marked completed and opens it to review the attached photo and notes. Pleased with the quick turnaround, she generates a report of completed orders for the day to send to management.* (Outcome: The supervisor efficiently distributes work and monitors field activity without phone calls.)
  * **Acceptance Criteria**
  * **Given** there are one or more open work orders in the system, when Maria (Field Supervisor) logs into the dashboard, then she can view a list of all open work orders with key details (e.g. locations, priorities, statuses).
  * **Given** a high-priority repair job is unassigned and technicians have location data, when Maria assigns the job through the interface, then the system recommends an appropriate technician (e.g. nearest available) and allows Maria to confirm the assignment, updating the work order’s status to “Assigned” with the technician’s name.
  * **Given** Maria has assigned a work order to a technician, when that technician (Frank) marks the work as completed in the field, then Maria’s web dashboard updates the task status to “Completed” in real-time and she can open the work order to review details (including any attached photos and notes).
  * **Given** a day’s field work has concluded, when Maria requests or generates a report of completed orders for that day, then the system produces a report listing all completed work orders and their key details (technician, completion time, notes) which Maria can download or forward to management.

* **Scenario 3: Offline Data Sync (Edge Case):** *While working underground, Frank cannot upload data. The scenario of offline mode kicks in: the app queues Frank’s updates. Frank finishes 3 jobs while offline. Once he returns to an area with coverage, he opens the app and sees a notification “3 work orders pending upload.” He taps “Sync Now,” and the data transmits. The central system is updated, and Maria’s dashboard now reflects those jobs as completed.* (Outcome: Offline work is gracefully handled, preventing data loss.)
  * **Acceptance Criteria**
  * **Given** the field technician is performing work orders in an area with no network connectivity, when the app is offline, then all of the technician’s inputs (completed tasks, notes, photos for each job) are queued/stored safely on the device and an indicator shows pending uploads (e.g. “3 work orders pending upload”).
  * **Given** there are pending work order updates waiting to sync, when the device later connects to a network (or the technician manually initiates a sync), then the app successfully uploads all queued work order data to the central system and updates each work order’s status to completed.
  * **Given** the offline updates have been synced, when the sync is finished, then the technician receives a confirmation (e.g. a notification or status message that all data is synced), and the supervisor’s dashboard reflects those work orders as completed (just as if they had been updated in real-time).

Prerequisites:

* Knowledge of the **users’ workflows** and daily routines to craft realistic scenarios. This often comes from process documentation or user interviews.
* Understanding of the **product features** that will support these scenarios (so that you don’t describe something the product won’t do). Early design thinking or requirements brainstorming helps shape these scenarios.
* Possibly a prior **“journey mapping”** exercise – sometimes teams map out a user’s journey through a task with pain points, then design the new solution. Those journey maps can feed into these scenarios.
* Familiarity with writing acceptance criteria for user stories, to ensure you can translate each scenario into testable conditions. This may involve collaboration with QA to understand how each scenario will be tested.

### Standards and Best Practices

User scenarios (or use cases) are a common way to ensure requirements are rooted in real user needs. Atlassian’s and Product School’s templates suggest including full **user stories or scenarios** about how personas will use the product in context. This narrative approach aligns with agile and user-centered design principles by keeping the focus on user goals. In more formal terms, it resembles use case modeling (UML use cases) where you describe interactions between an “actor” (user) and the system to achieve a goal. IEEE SRS standards often include use cases in an appendix or prior to functional requirements to illustrate requirements in context. Including scenarios here helps validate that the functional requirements (next section) adequately support all critical user flows. It’s also a communication tool – stakeholders can read a scenario and confirm “Yes, this is how we expect it to work.”

Additionally, it’s a best practice to include acceptance criteria with each scenario or user story. This ensures there is a clear definition of done for each feature. The acceptance criteria should be unambiguous and testable, so that during UAT and QA testing, everyone can agree whether each condition is met. By writing them in a Given/When/Then format (or as a checklist of verifiable statements), you make it easier to develop test cases and avoid misunderstandings about expected behavior  . Ultimately, well-defined acceptance criteria improve quality and serve as a contract that the development team, product owner, and QA all understand and sign off on.

## Functional Requirements & Features

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To enumerate the specific functional capabilities that the product must provide. This section breaks down the product into individual features or requirements, describing what the system should do to support the user needs and scenarios described earlier. It forms the core checklist for developers to implement and testers to verify.

Instructions:

* List the **functional requirements** of the product. There are two common ways to do this, and you can choose based on your methodology (or even combine them):

* **User Story format (Agile/XP):** Write requirements as user stories, e.g., “As a *\[user persona]*, I want *\[some capability]*, so that *\[benefit]*.” Each user story represents a feature or piece of functionality. Include acceptance criteria for each story if possible, to clarify when the story is “done.” (e.g., “Given I am logged in, when I submit a work order form offline, then it is saved locally and synced later.”)
  * **System Requirement format (Traditional/Waterfall):** Write statements of what the system accomplishes, these requirements follow this format: "The [System that this requirement is assigned to] [Shall {for requirements} | Will {for facts or declaration of purpose} | Should = {for goals}] [Do some capability or create some business outcome] while [some set of conditions need to be met that can be measured] [under some measurable constraint]. These should be clear, atomic requirements. They might be organized under feature headings (e.g., “Work Order Management” as a sub-section with multiple requirements). Each requirement can be tagged/numbered (e.g., REQ-1, REQ-2) for traceability.
  * **Acceptance Criteria:**  Write Acceptance Criteria for each requirement using Gherkin Scripts taken from Behavior-Driven Development, e.g., "*\[Scenario: A labor for the behavior being described]*: Given *\[The Starting Condition for the scenario to test, include any preconditions, environmental details, or relevant information]*, When *\[A specific action that the user takes or an automated process takes within the system takes]*. Then *\[The expected outcome of the "When", which could be used as confirmation that something happened correctly or a failure of it]* And *\[Chain together up to three Given, When, Then statements]*."
* Ensure that each requirement is **clear, testable, and necessary**. Avoid ambiguity. For instance, instead of “system should be user-friendly” (which is vague), specify “system shall allow a technician to complete the work order form in 5 minutes or less” or capture “user-friendly” aspects under UX requirements.
* It can be helpful to group requirements by feature area or module (matching perhaps the “Epics” or major features). For example: “Login & User Management,” “Work Order Processing,” “Mapping/GIS Features,” “Reporting,” etc., each with specific requirements.
* If priority or release phase is relevant, mark each requirement with a priority (High/Must-have, Medium/Nice-to-have, Low/Future) that link to the MoSCoW categories. In Agile, you might implicitly do this via backlog ordering, but in a PRD it’s often helpful to indicate critical vs optional features.
* Use bullet points or a numbered list for readability. Keep each requirement concise (one feature per statement). If additional explanation is needed for a requirement, you can indent a sub-bullet or add a brief rationale.
* Verify that every functional requirement traces back to a user need or objective (use the earlier sections to ensure coverage).

Example:

* **Work Order Management:**

1. [Scenario: Viewing Assigned Work Orders] - “As a Field Technician, I want to view a list of my assigned work orders for the day, so that I can plan and prioritize my tasks.”

* **Given** the Field Technician logs into the mobile application at the start of the day and has at least one work order assigned,
  * When the technician navigates to the “Today’s Work Orders” section,
  * Then the system shall display a list of work orders showing order ID, location, priority, and due date.
  * And the list shall be sorted first by priority (descending), then by due time (ascending).

2. [Scenario: Updating Work Orders While Offline] - "The system shall allow the Field Technician to update a work order’s status and record task results while offline."

* **Given** the Field Technician is working in an offline environment and opens a previously downloaded work order,
  **When**  they update the status of the work order to “Started,” add notes, and attach photos,
  **Then** the system shall allow all changes and store them locally on the device.
* **Given** a network connection is later established,
  **When**  the application detects connectivity or the technician taps “Sync Now,”
  **Then** the stored data shall be uploaded to the central server and reflected in the supervisor’s dashboard in real time.

3. [Scenario: Notifying Supervisor on High-Priority Completion] - "The system shall send a notification to the supervisor when a high-priority work order is completed."

* **Given** a Field Technician completes a work order that is marked as high priority and updates its status to “Completed,”
  **When**  the application syncs this change to the server,
  **Then** a push notification or alert message shall be sent to the assigned Supervisor’s device or dashboard immediately.
  **And** the notification shall include the work order ID, location, and technician name.

4. [Scenario: Viewing Work Orders on a Map] - “As a Field Technician, I want to see the location of my work orders on a map, so that I can navigate to the site efficiently.”

* **Given** the technician opens the “Map View” screen within the app while online,
  **When**  the system loads the map tiles for the current and upcoming work order locations,
  **Then** pin markers shall be displayed for each assigned work order with basic details accessible upon tap.
* **Given** the technician loses internet connection,
  **When**  they reopen the app in an offline area,
  **Then** the previously loaded map and work order markers shall remain visible and functional,
  **And** tapping a marker shall still show work order info and provide an option to open the location in an external navigation app.

5. [Scenario: Logging in with Corporate SSO] - "The system shall integrate with the corporate Single Sign-On (SSO)."

* **Given** the user opens the mobile or web app and is not logged in,
  **When**  they click “Sign in,”
  **Then** the system shall redirect to the corporate SSO login screen and accept valid company credentials.
* **Given** the credentials are valid,
  **When**  the user successfully authenticates,
  **Then** the system shall create a session and route the user to their appropriate dashboard.
  **And** no separate app-specific password shall be required.

6. [Scenario: Enforcing Role-Based Access Control] - The system shall enforce role-based access control.

* **Given** a user logs into the system,
  **When**  their role is identified as Technician,
  **Then** they shall only be able to view and update work orders assigned to them.
* **Given** a Supervisor logs in,
  **When**  they access the work order list,
  **Then** they shall be able to view and reassign work orders within their region.
* **Given** an Admin user logs in,
  **When**  they navigate to the user management or audit section,
  **Then** they shall be able to view all user accounts, roles, and audit logs across all regions.

7. [Scenario: Downloading a Daily Summary Report] - “As a Field Supervisor, I want to download a daily summary report of completed and pending work orders, so that I can report progress to management.”

* **Given** the Supervisor logs into the web dashboard before 5 PM,
  **When**  they navigate to the “Daily Reports” section and select “Download,”
  **Then** the system shall generate a report (PDF or Excel) including all completed and pending work orders as of that day.
  **And** the report shall include metadata such as task IDs, completion timestamps, technician names, and any overdue items.

Prerequisites:

* You should have completed the **user scenarios** and have a good understanding of what functions are needed. Ideally, you’ve also consulted subject matter experts or users to validate these functions.
* If following Agile, a **product backlog** or list of user stories might already exist from discovery workshops – those can be refined and included here. If following a traditional approach, a business requirements document or use case documents might have been created, which you now translate into functional requirements.
* The team should align on a **level of detail** for requirements. Sometimes early PRDs keep it higher-level (epics/features), especially in agile contexts, deferring detailed user stories to the backlog. Make sure this section’s granularity matches how the team will implement (e.g., each bullet could correspond to a backlog item or development task).
* Acceptance Criteria should be completed as the stories and the requirements are finalized.  If the stories and requirements are not finalized, then the Acceptance Criteria needs to be updated every time the associated need is changed.
* Before Acceptance Criteria is finalized, there needs to be an agreement with the customer and business process owner where the testing will take place (Test Environment) and which datasets will be used.

### Standards and Best Practices

Functional requirements should be *clear, unambiguous, and verifiable*. According to IEEE standards, each requirement should be concise, complete, and testable. In a Waterfall model, you might enumerate “The system shall…” statements with unique identifiers. In Agile, writing user stories is common; when doing so, follow the **INVEST criteria** – each story should be Independent, Negotiable, Valuable, Estimable, Small, and Testable. For example, ensure every user story clearly states the value (so that it’s truly needed) and is small enough to implement in a short iteration. It’s also advisable to avoid prescribing the solution in this section – focus on *what* the system should do, not *how* to do it (leave design decisions for later), unless a particular implementation is a constraint. By adhering to these guidelines, the requirements become actionable for development and measurable for QA.  INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile Definition‑of‑Done checklists.

## UI / UX Design Specifications

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Describe how the product should look and feel so that developers and designers
deliver a consistent, user‑friendly experience aligned with corporate style and
field‑use constraints.

Instructions:

1. Design Principles – List the key principles to follow (e.g., “mobile first,”
  “glove‑friendly controls,” “minimal data entry”).
2. Visual Standards – Reference corporate style‑guide elements: color palette,
  typography, spacing, iconography.
3. Interaction Patterns – Define reusable UI patterns (e.g., bottom‑navigation
  bar, modal confirmation dialogs, offline status banner).
4. Accessibility – Specify WCAG 2.1 AA criteria the app must meet (contrast
  ratios, alternative text, focus order, etc.).
5. Artifacts – Link to wireframes, high‑fidelity mock‑ups, interactive
  prototypes, and a component library (e.g., Figma file).
6. Usability KPIs – List measurable UX targets (task completion time, error
  rate, SUS score).

Example:

* Design Principle: “Field‑Friendly.” All actionable controls ≥ 44 × 44 px;
  primary buttons left‑aligned for one‑handed thumb use.
* Visual Standards: Use Blue Fire #00A9E0 for primary actions; body text 16 pt
  San Francisco; icons from the internal Ion Icon set.
* Interaction Patterns: Swipe‑to‑complete pattern for quickly closing a work
  order.
* Accessibility: All static text passes 4.5:1 contrast; voice‑over labels
  present on every icon.
* Artifacts: See Figma → Field App v2 → Frames 1‑20 for annotated mock‑ups.
* Usability KPIs - These Key Performance Indicators (KPIs) measure how usable
  and efficient the Field Service Mobile App is for real-world use by utility
  field technicians and supervisors.
  * **SUS**, **error rates**, and **first-time success** should be measured via
    pilot studies or usability tests.
  * **Tap accuracy**, **task time**, and **navigation steps** can be tracked via
    usage analytics or observed in test labs.
  * KPIs should be reviewed after initial deployment and used to inform
    iterative UX improvements.

| **KPI Name**                           | **Target**                                                                          | **Rationale**                                                                     |
|----------------------------------------|-------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------|
| **Task Completion Rate**               | ≥ 95% of users can complete core tasks (e.g., update work order) without assistance | Confirms the system is intuitive and meets baseline usability expectations.       |
| **First-Time Task Success**            | ≥ 90% of new users complete a task without training                                 | Measures learnability for new or infrequent users; critical for field deployment. |
| **Time to Complete Work Order**        | Median time < 3 minutes                                                             | Ensures workflows are efficient and do not slow down field operations.            |
| **Error Rate per Task**                | < 2% user-generated errors (e.g., failed submissions)                               | Indicates clarity of design and resilience to user mistakes.                      |
| **System Usability Scale (SUS) Score** | ≥ 75 (from technician surveys post-deployment)                                      | Benchmarks user satisfaction against industry standards.                          |
| **Tap Accuracy Rate**                  | ≥ 98% for key UI controls (buttons, lists, inputs)                                  | Ensures UI is accessible with gloves and in adverse field conditions.             |
| **Offline Sync Success Rate**          | ≥ 99% of queued tasks sync successfully after reconnecting                          | Validates offline mode robustness for areas with poor or no connectivity.         |
| **Training Time for New Users**        | ≤ 1 hour to reach basic proficiency                                                 | Ensures the app is simple enough for rapid onboarding and minimal friction.       |
| **Navigation Steps per Task**          | ≤ 3 taps to complete a primary task                                                 | Minimizes cognitive load and streamlines daily work for field crews.              |
| **Help/Support Usage Rate**            | ≤ 10% of users need in-app help or raise support tickets                            | Low support needs suggest intuitive design and clear workflows.                   |

Prerequisites:

* Finalized corporate style guide and component library access.
* UX research insights/persona pain points.
* Device usage constraints (sunlight readability, glove use, etc.).

Standards & Best Practices:

WCAG 2.1, ISO 9241‐210 (Human‑centred design), Nielsen 10 usability heuristics,
Apple HIG / Material Guidelines (for native iOS/Android patterns).

## Data Management & Governance

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Define how data is created, owned, classified, governed, audited, and
lifecycle-managed within the product. This section establishes authoritative
sources, accountability, lineage, and auditability for all data handled by the
system, ensuring regulatory compliance, operational integrity, and long-term
maintainability in a utility environment.

Instructions:

1. **Identify core data entities**

* Enumerate all primary and secondary data entities the product creates,
    reads, updates, or stores (e.g., work orders, assets, inspections, photos,
    notes, telemetry).
  * Include derived and transient data where operationally significant.

2. **Define system of record (SoR)**

* For each data entity:

* Identify the authoritative system of record.
    * State whether this product is:

* The system of record
      * A system of entry
      * A system of reference/replica
  * Explicitly prohibit ambiguous ownership.

3. **Assign data ownership and stewardship**

* For each data entity:

* Identify the **Business Data Owner** (accountable for correctness and
      use).
    * Identify the **Data Steward** (responsible for quality, definitions, and
      access).
    * Identify the **Technical Custodian** (responsible for storage and
      pipelines).

4. **Classify data**

* Classify each data entity according to enterprise data classification
    policy.
  * Explicitly flag:

* PII / SPI
    * CIP-sensitive or operationally sensitive data
    * Safety-critical data
  * Define handling requirements by classification.

5. **Define data lineage**

* For each data entity:

* Identify source system(s).
    * Describe transformations, enrichments, or aggregations.
    * Identify downstream consumers (systems, reports, regulatory outputs).
  * Capture lineage at a logical level (not implementation detail).

6. **Define synchronization and conflict resolution rules**

* For data that may be edited or created in multiple systems:

* Define authoritative write rules.
    * Define conflict detection triggers.
    * Define conflict resolution policy (automatic, manual, precedence-based).
  * State rules as **product behavior**, not technical patterns.

7. **Define retention, logging, and audit artifacts**

* For each data entity:

* Define retention duration.
    * Define archival vs deletion rules.
  * Define audit artifacts that must be producible:

* What evidence
    * In what format
    * Within what time window

8. **Define data access and usage constraints**

* Define role-based access expectations.
  * Define permitted vs prohibited secondary uses of data.
  * Identify data-sharing constraints with external systems.

Example:

**Core Data Entities**

| Data Entity      | System of Record                  | Business Owner           | Data Steward            | Classification          |
| ---------------- | --------------------------------- | ------------------------ | ----------------------- | ----------------------- |
| Work Order       | Work Management System (WMS)      | Director, Operations     | Operations Data Steward | Operationally Sensitive |
| Asset            | Enterprise Asset Management (EAM) | Director, Asset Strategy | Asset Data Steward      | CIP-Sensitive           |
| Inspection Photo | This Product                      | Director, Field Ops      | Field Data Steward      | PII / Operational       |
| Technician Notes | This Product                      | Director, Field Ops      | Field Data Steward      | PII                     |

**System of Record Rules**

* This product is **not** the system of record for Work Orders or Assets.
* This product **is** the system of record for Inspection Photos and Notes.
* Updates to Work Order status must be written back to WMS within 5 minutes or
  queued for retry.

**Data Lineage**

* Work Order:

* Source: WMS
  * Enrichment: Location metadata from GIS
  * Consumers: Reporting Warehouse, Regulatory Audit Reports
* Inspection Photos:

* Source: Mobile Client
  * Transformation: Compression, metadata tagging
  * Consumers: Safety Review, Claims Investigation

**Synchronization & Conflict Resolution**

* Offline edits allowed for Inspection Notes.
* Conflict detected when server version updated after client sync timestamp.
* Resolution policy:

* Server version retained as authoritative.
  * Client version stored as supplemental record.
  * Supervisor review required for merge.

**Audit Artifacts**

* Ability to produce:

* Full work order change history
  * Timestamped photo metadata (who, where, when)
  * Access logs for CIP-sensitive data
* Evidence must be producible within 5 business days of request.

**Retention**

* Inspection Photos: 7 years
* Notes: 7 years
* Sync logs: 90 days
* Access logs: 1 year

Prerequisites:

* Functional requirements defined.
* Non-functional and security requirements identified.
* Enterprise data classification policy available.
* Stakeholders and data owners identified.
* Upstream and downstream systems known.

### Standards and Best Practices

* DAMA-DMBOK (Data Governance and Stewardship)
* ISO/IEC 27001 (Information Security Management)
* NIST SP 800-53 (Data protection and auditing controls)
* NERC CIP (for electric utilities)
* GDPR / CCPA (for PII handling, where applicable)
* ITIL 4 – Information Management
* Utility best practice: always name a system of record per entity
* Treat sync conflict rules as product policy, not technical implementation
* Design audit evidence first, not after an incident
* Prefer lineage clarity over technical completeness

## Security & Compliance Requirements

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To detail the specific security measures and compliance obligations the product must adhere to. This section is crucial for a utility company, as such companies operate critical infrastructure and are subject to strict regulations (e.g., cybersecurity standards, data privacy laws, safety regulations). It ensures that security is built into the product from the start and that the product will not violate any legal or regulatory requirements.

Instructions:

* **Security Requirements:** List the security controls and features that the product must implement. This can include:

* **Authentication & Authorization:** e.g., “Must integrate with Single Sign-On (SSO) using company credentials” (as noted in functional req, but reiterate here if needed), “Users are assigned roles with least privilege access (technicians cannot access admin features, etc.).”
  * **Encryption:** “All data in transit must be encrypted (TLS), and sensitive data at rest encrypted (AES-256, etc.).”
  * **Data Protection:** e.g., “The mobile app shall store data in an encrypted format on-device and wipe cached data after X days.”
  * **Logging & Auditing:** “System must log user actions like login, data changes, and have audit logs that can be reviewed. Logs should include user ID, timestamp, action, and be tamper-evident.”
  * **Security Testing & Compliance Checks:** e.g., “The product must pass a penetration test by the internal security team before go-live” or “Must comply with OWASP Top 10; no critical or high vulnerabilities in final security scan.”
* **Regulatory Compliance:** List any external regulations or standards the product must comply with, and specific requirements to meet them. Examples relevant to a California utility IT product:

* **NERC CIP (Critical Infrastructure Protection standards):** If the system is part of bulk electric system operations or contains critical cyber assets. Requirements might include strong access controls, background checks for admins (maybe not directly in software but process), specific logging and incident response features. *For example:* “The system must comply with NERC CIP standards for cybersecurity, including role-based access control, annual cyber vulnerability assessments, and strict change management logging for any software modifications.”
  * **California Consumer Privacy Act (CCPA):** If the product deals with personal data (even employee personal data or customer data), ensure compliance with data handling rules. e.g., “If any personal identifiable information (PII) is stored (like customer contact within a work order), the system must allow for data removal and disclosure reporting per CCPA requirements.”
  * **California/OSHA Safety Regulations:** If the software usage intersects with safety (like field use in hazardous areas), ensure compliance with any safety policies. E.g., “The app will include a safety acknowledgment for switching operations, as required by OSHA and company policy.”
  * **Records Retention Laws:** Utilities often must retain certain records. If this app’s data is subject to CPUC or FERC record retention rules, state those (which might overlap with NFR data retention in previous section).
  * **Internal Compliance:** e.g., internal IT compliance standards, like “Must comply with Company XYZ’s Software Development Lifecycle requirements, including code review and change management processes as audited by internal compliance.”
* **Industry Standards:** Mention any other relevant standards: e.g., “Encryption must follow NIST guidelines (FIPS 140-2 compliant cryptographic modules)” or “The system should comply with IEC 62351 (security for IEC 61850 systems) if relevant to substation communications” – only if applicable.
* Each requirement should be clear and testable. Some compliance requirements may require documentation rather than features (e.g., proving via audit that you meet them). Still, list what the system needs to provide or allow to ensure compliance.

Example:

* **Authentication & Access Control:** The application shall utilize **Azure Active Directory SSO** for user login. Technicians and supervisors authenticate with their corporate credentials and a second factor (MFA). The system will enforce role-based access as defined (Tech, Supervisor, Admin roles with predefined permissions). Account provisioning and de-provisioning will be handled via the corporate directory to ensure only current employees have access.
* **Given** a user (Technician, Supervisor, or Admin) launches the app,
  **When** they initiate login,
  **Then** they shall be redirected to the corporate **Azure Active Directory SSO** login page and prompted for their corporate credentials.
* **Given** the user enters valid credentials,
  **When** the system requests the second authentication factor,
  **Then** the user shall be authenticated via **MFA**, and upon success, be granted access to the system.
* **Given** the user’s role is known,
  **When** the login completes,
  **Then** the system shall enforce **role-based access controls**, restricting visible features and actions to those associated with their assigned role.
  **And** the account must be automatically provisioned or de-provisioned based on **Active Directory membership status**.
* **Audit Logging:** All critical actions (e.g., completing a work order, changing a work order assignment, admin changes to user roles) must be **logged with user ID, timestamp, and details**. Logs should be immutable (or properly secured against tampering) and exported to the central SIEM (Security Information and Event Management) system daily for monitoring.
  * **Given** a user completes a critical action (e.g., marking a work order complete, reassigning work, or changing user permissions),
    **When** the action is committed,
    **Then** the system shall create a **log entry** capturing the **user ID, timestamp, action type, and affected entity**.
  * **Given** logs are collected continuously throughout the day,
    **When** the scheduled export job runs daily,
    **Then** the logs shall be securely transmitted to the **central SIEM system** for monitoring and alerting.
    **And** the logs must be **immutable** (or write-once protected) to prevent tampering.
* **Data Encryption:** Data in transit between the mobile app and server will use HTTPS with TLS 1.2+. For data at rest, the server database will use encryption (TDE – Transparent Data Encryption). On the mobile device, local data caching will be encrypted using the device’s secure storage mechanism.
  * **Given** a technician’s mobile device connects to the server to transmit data,
    **When** the data exchange begins,
    **Then** the connection shall be secured using **HTTPS over TLS 1.2+** to encrypt data in transit.
  * **Given** data is stored on the backend database,
    **When** it is written to disk,
    **Then** the database shall employ **Transparent Data Encryption (TDE)** to protect the data at rest.
  * **Given** the mobile device caches any work order data locally,
    **When** that data is stored for offline access,
    **Then** it must be encrypted using the device’s **native secure storage mechanisms** (e.g., Android Keystore or iOS Keychain).
* **NERC CIP Compliance:** Although this application is not directly controlling the grid, if it stores or transmits any Bulk Electric System (BES) Cyber System information, it must adhere to **NERC CIP requirements**. Specifically:
  > * Unique user IDs for each person (no shared accounts) and MFA (meets CIP-005 remote access requirements).
  > * Audit logs as described align with CIP-007 logging requirements.
  > * If classified as a low-impact BES Cyber System, ensure an incident response plan exists (though this is procedural, the app should facilitate incident response by providing necessary logs).
  > * The development team will consult with the compliance team to ensure all relevant CIP controls (CIP-002 through CIP-011 series) are considered, even if the system likely falls outside high/medium BES classification.
  * **Given** the application may store or transmit data related to Bulk Electric System assets,
    **When** a user account is created,
    **Then** the system shall assign a **unique user ID** and disallow shared accounts, in accordance with **CIP-005**.
  * **Given** the user logs in remotely,
    **When** authentication is requested,
    **Then** **MFA** shall be enforced to meet **CIP-005 remote access standards**.
  * **Given** an action is performed within the system,
    **When** it qualifies as critical (e.g., work order completion, admin action),
    **Then** an **audit log entry** shall be generated in accordance with **CIP-007**.
  * **Given** a security event occurs,
    **When** the compliance team initiates an investigation,
    **Then** the system shall provide **sufficient logging** to support an incident response aligned with **CIP-008 and CIP-009** procedures.
* **Privacy (CCPA):** The system will store employee IDs and possibly names (for assignment, etc.). This is considered personal data. We must allow administrators to delete or anonymize personal data if an employee leaves, and protect it from unauthorized access. Any use of customer data (if any in future) will trigger full CCPA compliance including the ability to provide data copies and deletion upon request.
  * **Given** employee personal data (e.g., ID, name) is stored in the system,
    **When** an employee leaves the company,
    **Then** an **administrator shall be able to delete or anonymize** the personal data, and confirm removal through audit logs.
  * **Given** a data subject (employee or customer) requests a copy of their stored personal data,
    **When** an admin executes the export function,
    **Then** the system shall provide a complete **data export in a human-readable format** within the required timeframe.
  * **Given** data is no longer required for business or regulatory reasons,
    **When** a deletion request is valid,
    **Then** the system must purge the data securely,
    **And** prevent future unauthorized access.
* **Internal IT Compliance:** The project will undergo **Security Review and Approval** by the IT Security team prior to launch. All open security findings must be remediated or explicitly acknowledged by risk owners. Additionally, the app must comply with our **Software Quality Policy** – meaning it will not go live with any open Severity 1 or 2 defects, and must pass User Acceptance Testing including security test cases.
  * **Given** the app is ready for production deployment,
    **When** the Security Review is conducted by the corporate IT Security team,
    **Then** all **critical vulnerabilities (Severity 1 or 2)** must be **remediated or explicitly accepted by the designated risk owner**.
  * **Given** UAT is scheduled,
    **When** security-related test cases are executed,
    **Then** the system must pass **100% of UAT security validation tests** prior to go-live.
  * **Given** any Severity 1 or 2 defects are still open,
    **When** the release candidate is reviewed,
    **Then** deployment shall be **blocked until those defects are resolved or waived** with documented risk acceptance.
* **Physical Security & Safety:** The application will display a warning reminder when opened in a vehicle (to remind technicians not to use the app while driving) – aligning with our company’s safety policies for driving. This isn’t a regulatory mandate but a compliance with internal safety rules to reduce distracted driving incidents.
  * **Given** a field technician opens the mobile app while inside a moving vehicle,
    **When** the application is launched,
    **Then** a **safety warning message** shall be displayed reminding the user not to interact with the app while driving.
  * **Given** the technician dismisses the warning,
    **When** the app resumes functionality,
    **Then** no critical input features (e.g., submitting work order data) shall be automatically activated,
    **And** the app must not encourage interaction while the vehicle is in motion, in compliance with internal safety policy.

Prerequisites:

* Involvement of the **cybersecurity team** to identify relevant security requirements and any regulatory triggers (like NERC CIP applicability). Possibly perform a threat model or security risk assessment for the product to decide on controls.
* Reference to **compliance documents**: e.g., NERC CIP standards documentation, internal compliance checklists, California privacy laws summary. Ensure you have the latest requirements from those sources.
* Coordination with the **legal/regulatory department** if necessary, to confirm which laws/regulations impact this software (for instance, confirming whether CCPA applies to employee data, etc.).
* Corporate **IT policies** for security (most IT departments have standard requirements for new applications – like password policies, data encryption standards, etc., which should be integrated here).

### Standards and Best Practices

Utility companies are heavily regulated and are expected to build systems with compliance in mind. For instance, NERC CIP is a mandatory cybersecurity standard for power utilities – even if this system is not directly controlling the grid, adhering to CIP principles (like strong access control and logging) is a good practice. Also, following industry security frameworks such as **NIST SP 800-53** or the **OWASP ASVS** can guide comprehensive security requirements. From a PRD perspective, explicitly listing these requirements ensures they are not forgotten – security and compliance must be treated as first-class requirements. It’s much cheaper to design in compliance from the start than to retrofit later. In agile, one might even create “security user stories” or “compliance acceptance criteria” – either way, including them here provides clear visibility. Aligning with international standards like **ISO/IEC 27001** (information security management) can be mentioned if the organization follows it. Remember, failing to meet these requirements can have legal or financial consequences, so this section should be reviewed by domain experts (security/compliance officers) for completeness.  INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile Definition‑of‑Done checklists.

## Non-Functional Requirements / Quality Attributes

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To specify the criteria that judge the operation of the system, rather than
specific behaviors. These include performance, security, usability, reliability,
and other quality attributes. Non-functional requirements (NFRs) ensure that the
product not only does *what* it should, but does so with the desired level of
quality, speed, safety, etc., which is crucial in a utility context where
reliability and safety are paramount.

Instructions:

List and describe the key non-functional requirements. It’s often useful to
categorize them by type of quality attribute. Common categories include:

* **Performance & Scalability:** Requirements about response times, throughput,
  capacity, and scalability of the system. e.g., “The system shall support 500
  concurrent users with an average response time of <2 seconds for data
  retrieval operations.” or “Must handle up to 1000 work orders per day without
  degradation.” Also consider offline performance (like app should load within X
  seconds on device).
* **Reliability & Availability:** Define uptime or availability requirements
  (e.g., “99.9% uptime during business hours” or specific acceptable downtime
  per month). Also any requirements for fault tolerance (e.g., what happens if a
  sync fails?), and data backup/recovery (important for utility data – ensure no
  data loss).
* **Security:** (Can be in its own section, but you may list basic security NFRs
  here or cross-reference the Security section below.) For example, “All data in
  transit must be encrypted (TLS 1.2 or higher)” or “User sessions expire after
  15 minutes of inactivity.”
* **Usability & Accessibility:** Requirements about the user experience – e.g.,
  “The mobile app interface shall be usable with minimal training (target: field
  users can perform main tasks after 1 hour of training).” Or “The interface
  must adhere to corporate UX standards (fonts, colors) for consistency.” If
  accessibility is important: “The product should meet WCAG 2.1 AA guidelines
  for accessible design, to accommodate color blindness and screen reader
  usage.”
* **Maintainability & Extensibility:** e.g., “The system shall be built using
  modular architecture to allow future enhancements (like adding new task types)
  with minimal refactoring.” Or maintainability metrics such as “Important: Code
  will follow internal coding standards and will include unit tests for at least
  80% of new code.” These might not always be in a PRD (sometimes they’re in an
  engineering plan), but for internal projects it’s often relevant to note.
* **Compatibility:** e.g., “Must be compatible with Chrome and Edge browsers
  (latest two versions) for the web part,” or “Mobile app must support iOS 15
  and later.” Also any backward compatibility or data migration from old systems
  if relevant.
* **Regulatory/Compliance (non-functional aspects):** Some compliance
  requirements impose NFRs, like data retention (e.g., “System must retain field
  data for at least 5 years to meet regulatory audit requirements”) or audit
  logging (“System shall log all user actions related to work order completion
  for audit purposes”). If not covered in the Security & Compliance section,
  include them here.
* **Localization:** If the app will be used in multiple locales or languages
  (likely not for an internal utility app in California, but if Spanish support
  is needed for some employees, mention that).
* **Other**: Any other quality requirements such as **Safety** (for example,
  “The software shall not distract the driver: if tech is driving, app locks
  certain features” – a safety requirement relevant to a utility where crews
  drive; or “Follow OSHA guidelines for electronic devices usage in hazardous
  areas” if any), or **Environmental conditions** (e.g., “Tablet screen must
  remain readable in bright sunlight” – which is more of a hardware spec but can
  be noted).

Use bullet points, each starting with the category or a short name of the NFR
followed by the specific requirement. Provide measurable criteria where possible
(e.g., actual numbers for performance, dates for retention, etc.).

Example:

* **Performance:** The mobile app shall load the day’s work orders in **under 5
  seconds** on average (when online). The system backend must support processing
  **up to 100 work order updates per minute** during peak usage (morning
  dispatch), without errors.
  * **Given** the Field Technician logs into the mobile app during active
    network connectivity and has one or more work orders assigned for the day,
    **When** the technician opens the “Today’s Work Orders” screen,
    **Then** the list of work orders shall load and render within **5 seconds**
    on average.
  * **Given** the backend server is processing incoming updates from the field
    during peak morning hours (e.g., 7–9 AM),
    **When** up to **100 work order updates per minute** are submitted
    simultaneously,
    **Then** the system shall accept and persist all updates without producing
    errors,
    **And** the average processing latency shall remain within operational
    thresholds (e.g., under 1.5s per request).
* **Availability:** The system (server side) should achieve **99.5% uptime**
  during 6am-6pm Monday-Saturday (field operation hours). Scheduled maintenance
  windows must be communicated and preferably performed off these peak hours.
  The mobile app shall allow offline operation for at least **8 hours** and
  queue data for later sync to ensure continuous work in case of network outages
  (supports reliability in the field).
  * **Given** it is between 6:00 AM and 6:00 PM on Monday through Saturday,
    **When** a field technician or supervisor attempts to connect to the system,
    **Then** the backend service shall be available at least **99.5%** of the
    time without interruption.
  * **Given** maintenance is required for the backend infrastructure,
    **When** a scheduled window is planned,
    **Then** it shall be communicated to all users in advance and occur
    **outside field operation hours** when possible.
  * **Given** the mobile app is offline due to poor signal,
    **When** a technician performs updates for up to **8 hours**,
    **Then** the system shall store all data locally and queue it for sync once
    network connectivity returns.
* **Security:** All API communication between the mobile app and backend will
  use **TLS 1.2+ encryption**. Sensitive fields (e.g., crew personal info, if
  any) should be encrypted in the database. The application must enforce
  **Multi-Factor Authentication** on login when off-site (in line with corporate
  security policy).
  * **Given** a technician is using the mobile app,
    **When** the app communicates with the backend API,
    **Then** all requests and responses shall be encrypted using **TLS 1.2 or
    higher**.
  * **Given** a user’s session contains sensitive data (e.g., personal crew
    info),
    **When** it is written to the backend database,
    **Then** all sensitive fields shall be **encrypted at rest** using approved
    encryption methods.
  * **Given** a user is attempting to log in from an off-site location,
    **When** authentication is initiated,
    **Then** the application shall enforce **multi-factor authentication** per
    corporate policy.
* **Usability:** The app’s UI shall be **simple and uncluttered**, with large
  buttons suitable for use with gloves. Use of text input is minimized
  (preferring picklists, voice-to-text, or scanning where possible) to
  accommodate field conditions. The design will follow the company’s UI style
  guide for consistency. New users (field techs) should be able to perform basic
  functions (view tasks, update status) with **no more than 1 hour of
  training**.
  * **Given** the Field Technician is operating in a harsh environment (e.g.,
    gloves, bright sunlight),
    **When** they use the mobile app,
    **Then** the UI shall display **large, accessible buttons** and avoid small
    or cluttered elements.
  * **Given** an input is required,
    **When** the user selects or enters data,
    **Then** the system shall prefer **picklists, voice input, or barcode
    scanning** over free-text entry.
  * **Given** a new technician is onboarded,
    **When** they are trained for 1 hour or less,
    **Then** they shall be able to **view assigned tasks and update task status
    without assistance**.
* **Accessibility:** (If applicable) The web portal shall meet **WCAG 2.1 AA**
  standards – for example, it should support screen readers for visually
  impaired office staff and have sufficient color contrast. (Mobile app should
  at least have scalable text and colorblind-friendly icons.)
  * **Given** a visually impaired user accesses the **web portal**,
    **When** they use screen reader software,
    **Then** the portal shall **meet WCAG 2.1 AA standards**, including labeled
    form fields, navigation hints, and alternative text for icons.
  * **Given** a colorblind user opens the mobile app,
    **When** viewing task status indicators or buttons,
    **Then** icons shall include **textual or shape-based cues**, and all color
    usage shall maintain a **minimum contrast ratio of 4.5:1**.
  * **Given** a user requires larger text,
    **When** system font scaling is enabled on the device,
    **Then** the app shall honor accessibility settings and **scale UI text
    appropriately** without layout breakage.
* **Maintainability:** The solution should be built on **standard
  company-supported frameworks**. All code will include documentation comments.
  We will also provide an **admin interface** for common configurations (so
  changes like adding a new work order type don’t require a code change).
  * **Given** the system is deployed and in active use,
    **When** engineers review the source code,
    **Then** all components shall follow **company-supported frameworks** and
    include **documentation comments** in-line.
  * **Given** an administrator needs to configure a new work order type or
    region,
    **When** they access the admin panel,
    **Then** such settings shall be **available without requiring a code change
    or deployment**,
    **And** the configuration shall be audit-logged and version-controlled.
* **Data Retention:** All work order completion records must be stored for **at
  least 5 years** in the central database to comply with regulatory
  record-keeping requirements. Audit logs of user actions should be retained for
  **1 year**.
  * **Given** a technician completes a work order,
    **When** the data is synced with the backend,
    **Then** the work order record shall be **retained in the central database
    for no less than 5 years**.
  * **Given** a user performs actions within the system (e.g., edit, delete,
    assign),
    **When** those actions occur,
    **Then** an **audit log entry** shall be created and retained for a
    **minimum of 1 year**,
    **And** these logs shall be searchable by Admin users for compliance or
    troubleshooting.
* **Interoperability:** The system should use standardized data formats (e.g.,
  JSON for APIs with field naming aligned to industry standards where possible)
  so that future integrations (such as with analytics tools or external
  contractors’ systems) can be done with minimal transformation.
* **Given** a third-party system or future integration is added (e.g.,
  analytics, contractor apps),
  **When** it interfaces with the backend APIs,
  **Then** all APIs shall return and accept data in **JSON format** with field
  names aligned to industry standards.
* **Given** another system consumes exported work order data,
  **When** the export is generated,
  **Then** the data shall be easily **parseable without custom transformation**,
  **And** should require minimal mapping to external schemas.

Prerequisites:

* Consult corporate **IT non-functional requirements guidelines** or checklists
  (many organizations have a security checklist, performance criteria, etc., for
  new applications).
* Involve specialists: e.g., Performance engineers for load expectations,
  Security team for specific security requirements, UX designers for usability
  heuristics.
* Review any **regulatory documents** for explicit non-functional mandates (like
  data retention from regulations, or specific safety rules). For a California
  electric utility, reliability standards (like not losing data) and security
  (NERC CIP) are often mandated.
* Determine usage assumptions: how many users, how often they’ll use it, which
  informs performance and capacity requirements.

### Standards and Best Practices

Covering a broad range of quality attributes aligns with industry standards like
**ISO/IEC 25010** (which defines product quality characteristics such as
reliability, performance efficiency, usability, security, maintainability,
portability, etc.). Ensuring each of these relevant attributes is addressed
helps create a well-rounded product. For example, **reliability** is critical
for utility software – downtime can affect operations, so stating uptime
requirements is important. **Security** standards (e.g., following OWASP Top 10
for web/mobile security) should be referenced if applicable. Many organizations
also adhere to **NIST** guidelines for cybersecurity and data protection – our
PRD’s security NFRs should reflect those. By specifying these NFRs, we provide
clear criteria for acceptance: the product isn’t done just when features are
built, but when it meets performance benchmarks, passes security tests, and so
on. INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile
Definition‑of‑Done checklists.

## Product Architecture Overview

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Present the high‑level technical architecture—major components, data flows, and architectural patterns—so that engineers share a common blueprint and non‑technical stakeholders grasp how the solution hangs together.

Instructions:

1. Architecture Diagram – Provide or link to a C4‑level 2 or UML component diagram (PNG/SVG) showing mobile app, backend services, data stores, external systems.
2. Component Descriptions – List each component with purpose, tech stack, key patterns.
3. Integration Points – Describe protocols (REST/JSON, MQTT, message bus), authentication method, expected SLAs.
4. Patterns & Tactics – Mention architectural patterns (micro‑services, offline‑first sync, CQRS, event sourcing) and quality‑attribute tactics (retry logic, circuit breaker).
5. Deployment View – Note hosting (Azure App Service, on‑prem K8s, etc.) and CI/CD pipeline outline.
6. Security Zones – Identify trust boundaries (DMZ, internal subnet, device).
7. Keep this section brief; deeper detail belongs in a separate Solution Architecture Document (SAD) referenced here.

Example:

**Components**

* Mobile App (iOS/Swift UI) – Presentation + local SQLite cache + sync engine using offline‑first pattern.
* API Gateway (Azure APIM) – Single entry point, JWT validation, request throttling.
* Work‑Order Service (Java/Spring Boot) – Stateless micro‑service exposing REST endpoints, communicates with Maximo via vendor API adapter.
* Sync Service (Node.js) – Handles delta sync, conflict resolution, pushes WebSocket notifications.
* Reporting Service (Python/FastAPI) – Generates PDF/Excel via queued jobs, stores files in Blob Storage with SAS tokens.
* AuthN/AuthZ – Azure AD B2E + OAuth 2.0; roles mapped from AD groups.
* Oracle DB 19c – Authoritative store for mobile‑captured data and audit logs.
* Logging & Monitoring – ELK stack + Azure Monitor; dashboards for uptime, latency, error rates.

**Patterns Used**

* Micro‑service architecture with API Gateway.
* Event‑driven messaging (Azure Service Bus) for decoupled sync and reporting.
* Offline‑first with conflict‑resolution strategy (last‑write‑wins + supervisor override).
* Infrastructure as Code (Terraform) and blue‑green deploy for zero‑downtime releases.

Prerequisites:

* Alignment with enterprise architecture principles.
* Selection of hosting option (cloud/on‑prem).
* Security review of proposed patterns (e.g., event bus encryption, API rate‑limiting).

Standards & Best Practices:

C4 model, ISO/IEC/IEEE 42010 (architecture description), Azure Well-Architected Framework, NIST Cloud Security guidance, **TOGAF (The Open Group Architecture Framework)**.

## Assumptions & Dependencies

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To document assumptions that have been made during requirements definition and any external dependencies that the project or product has. This section highlights things that are believed to be true (but not yet confirmed) and what the product relies on, so that risks can be identified if assumptions turn out false or if dependencies change. It helps in risk management and planning by making these factors explicit.

Instructions:

* **Assumptions:** List any assumptions about users, technology, business processes, or external conditions that are relevant to the requirements. These are conditions we assume to be true without concrete proof, often because they are outside the project’s immediate control or will be validated later. For example:

* Assumptions about **user behavior or availability**: “We assume field technicians will have a company-issued tablet to use this app” or “Assume users will have basic training on mobile device use.”
  * Assumptions about **operational environment**: “Assume cellular network coverage is available at least 80% of the time in service territory” (for offline design justification).
  * Assumptions about **project support**: “It is assumed that the necessary funding and resources (developers, testers) will be available throughout the project per the schedule.”
  * Assumptions about **data**: “We assume that the quality of data from the Work Management System (e.g., equipment IDs, locations) is high, and no extensive data cleanup is required prior to integration.”
  * Any assumption about **user acceptance**: “We assume field users will adopt the new app if it meets their needs; change management will be handled by operations team.”
* **Dependencies:** List external dependencies that the project relies on. These could be:

* **Systems/Software Dependencies:** e.g., “Depends on the GIS mapping service provided by XYZ; if that service is down, mapping features won’t work.” Or “We rely on the corporate Oracle database environment – our project is dependent on the IT infrastructure team to provision a database instance.”
  * **Team/Resource Dependencies:** e.g., “The project depends on the Networking team to open firewall access for mobile devices,” or “Dependency on vendor ABC to deliver the API for the Work Management System by July 2025.”
  * **External Events:** e.g., “Deployment of this app depends on completion of another project (like an API development project or a device rollout project).”
  * **Compliance Dependencies:** e.g., “Awaiting regulatory approval of using cloud for this data – project depends on legal clearance.” (This could be considered a risk too, but if it’s something like needing a sign-off, list it.)
  * **Integrations:** if integration with a third-party software is needed, that’s a dependency (and possibly the third-party’s timeline/availability is a factor).
* For each item, you can add a note on the impact or plan: e.g., “If this assumption fails (e.g., if technicians don’t have devices), then \[what’s the contingency].” Or for dependencies, note the expected delivery, e.g., “WMS API – expected by Q3 2025 from integration team.” This overlaps with risk management, but at least stating them clearly is the first step.

Example:

* **Assumptions:**

* It is assumed that **field technicians will have internet connectivity** at least 80% of their work time. The app’s offline mode is designed for brief outages, not days of no connectivity. If connectivity is significantly worse, requirements for offline data caching might need to be extended.
  * We assume **technicians will carry the company-issued tablets** during work hours. (If in reality they sometimes don’t, certain real-time features like instant notifications may not be effective.)
  * We assume the **user data in the corporate directory is up-to-date** (employee roles, etc., for role-based access). E.g., if someone’s role changes or they leave, HR updates AD promptly so the app’s access remains correct.
  * The project assumes **no major organizational change** (like restructuring of the field operations process) will occur during development that would alter fundamental requirements.
  * We are assuming **acceptance of new technology by users**: Field crews have been consulted and management assures their buy-in. (We assume adequate training and change management will be provided outside of this PRD scope.)

* **Dependencies:**

* **Work Management System (Maximo) API:** The new app depends on the WMS team delivering a stable API. *Dependency Detail:* The integration team is scheduled to finalize the API endpoints by Aug 2025. Any delay or change in the API spec will impact our development timeline.
  * **GIS Mapping Service:** We rely on the internal GIS service (ArcGIS server) to provide map tiles and asset locations. This dependency means the app’s mapping feature is subject to the GIS service’s performance and maintenance schedule. We’ll need the GIS team’s support to ensure uptime.
  * **IT Infrastructure Provisioning:** The project depends on IT Ops to provision a production server environment (or cloud resources) by the time we start testing (Oct 2025). Any delay in provisioning could delay testing and deployment.
  * **Mobile Device Deployment:** The success of the app depends on all target users having a compatible device. The plan is for the Mobile Device team to roll out new iPads to all technicians by Dec 2025. Our training and launch assume devices are in place.
  * **External Vendor Tool (if any):** (Example scenario) If we use a 3rd-party library for PDF report generation, we depend on that vendor’s library being approved by IT Security and available for use.
  * **Regulatory Approval:** (If applicable) The app features (like digital signatures for clearance tags) might need sign-off from regulatory or safety authorities. For instance, using electronic signatures in lieu of paper might need approval from a safety standards committee – our timeline assumes this approval is granted by test phase.

Prerequisites:

* Brainstorm with the project team and stakeholders about what you are **assuming** to be true. Often assumptions hide in other discussions; it’s good to surface them.
* Identify all **external parties or systems** that our work interfaces with (other teams, vendors, etc.) to list dependencies. Check project plans or integration documents for dependencies.
* Review the plan to catch any “if this doesn’t happen, we’re blocked” items – those are dependencies or critical assumptions.
* Document any **constraints** that are actually assumptions (e.g., we might assume something won’t change – like “the legacy system will remain operational until we finish migration”).

### Standards and Best Practices

Listing assumptions and dependencies is a common practice in project and requirements documents. It allows teams to monitor these items and validate them over time. For example, PMBOK (Project Management Body of Knowledge) suggests documenting assumptions and constraints early in a project. The BABOK (Business Analysis Body of Knowledge) also highlights the importance of recording assumptions that could influence requirements. Moreover, clearly stated dependencies ensure that those responsible (other teams or vendors) are aware of the importance. It aligns with risk management standards – each assumption is essentially a risk (“if this turns out false”) that should be tracked. In agile contexts, dependencies are often managed in the product backlog or risk board, but having them in the PRD provides a one-stop overview of what the product team relies on. Regularly revisit this section: as the project progresses, confirm assumptions (or adjust if they prove false) and update the status of dependencies.

## Risks & Mitigations

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To identify major project and product risks and outline mitigation strategies for each. While not always included in a traditional PRD, documenting key risks in this context (internal project at a utility) is a best practice to ensure awareness and proactive management. This section helps prepare the team for potential challenges that could impact the product’s success (schedule delays, budget issues, technical hurdles, adoption problems, etc.).

Instructions:

* List the **key risks** that could threaten the project’s success or the product’s effectiveness. Focus on high-impact or high-likelihood risks. Categories of risks to consider:

* **Schedule Risk:** e.g., tight timeline, risk of delays due to dependency or resource constraints.
  * **Technical Risk:** e.g., new or unproven technology (if we’re using something new), integration complexity (WMS API might not perform as expected), performance concerns (will offline sync work with large data?), etc.
  * **Resource Risk:** e.g., key team members might be pulled away, or vendor support might be lacking.
  * **Scope/Requirements Risk:** e.g., risk of scope creep (stakeholders might want additional features mid-project), or risk that requirements change due to regulatory changes.
  * **User Adoption Risk:** e.g., field technicians might resist using the new app if not user-friendly or if training is insufficient.
  * **Compliance/Security Risk:** e.g., risk of a security breach if not properly secured, or risk of not meeting a compliance deadline if project slips.
  * **External Risk:** e.g., regulatory approval taking longer, or supply chain issues (if depending on hardware).
* For each risk, provide a brief **description** and then a **mitigation or contingency** plan. Mitigation is what you’ll do proactively to reduce the probability or impact of the risk. Contingency is what you’ll do if the risk event occurs. For this template, you can combine them in one statement if clear.
* Optionally, assign a **risk level** (High/Med/Low) or probability/impact score if your process uses that. This helps prioritize attention.
* The format can be bullet points or a table. A simple format is: **Risk:** description **Mitigation:** what we’ll do. Or separate line bullets for risk and mitigation.
* Ensure the risks listed are those that a PRD reader (developers, stakeholders) should be aware of; more detailed risk logs can exist elsewhere, but highlight the big ones here for visibility.

Example:

* **Risk: Integration API Delay** – *The Work Management System API might not be ready on time or might not have all required endpoints.* **Mitigation:** We are coordinating closely with the integration team with bi-weekly sync meetings. If the API is delayed, as a contingency we can develop a temporary data export/import as a fallback to keep progress, or stub the API responses for testing purposes. We’ve also scoped our development to start with features that don’t rely on the new API first, to allow buffer time.
* **Risk: User Adoption & Change Resistance** – *Field technicians might be hesitant to adopt the new app, preferring their familiar paper process.* **Mitigation:** Engage users early – include a few techs in a pilot group for feedback. Provide thorough training and ensure the app’s design is user-friendly (addressing their pain points, like offline usage and simplicity). Management will communicate the benefits and set expectations that the old process will be phased out. If adoption is slow, consider an incentive or additional support during transition (like on-site champions to help peers).
* **Risk: Performance Issues** – *The app might experience slow sync or crashes if too many work orders are handled (e.g., during storm emergencies when work volume spikes).* **Mitigation:** Set strict performance requirements (as above) and plan for load testing. If testing reveals issues, optimize code or scale up infrastructure (e.g., ensure servers auto-scale in cloud). Also design graceful degradation (maybe limiting the amount of data synced in one go). Contingency: have a manual process fallback for extreme cases (like if app is overwhelmed during a major emergency, techs might revert to radio communication until system catches up – not ideal but have that as a backup procedure).
* **Risk: Regulatory Compliance Change** – *New regulations or internal policy changes could introduce new requirements late (for example, a sudden mandate to log additional data for audits).* **Mitigation:** Keep compliance team in the loop throughout development to catch wind of upcoming changes. The design is being kept flexible (modular logging, etc.) to accommodate tweaks. If a new requirement emerges late, we may need to re-prioritize features or possibly schedule a follow-up release to address it.
* **Risk: Key Person Dependency** – *Our lead developer is the only one familiar with the legacy WMS integration.* **Mitigation:** Cross-train another developer on that component and maintain good documentation of the integration. If the lead becomes unavailable, the secondary person can step in with minimal ramp-up. Also, consider engaging the vendor’s support or consulting if needed to cover knowledge gaps.
* **Risk: Budget or Timeline Overrun** – *If we under-estimated the effort, we might run out of budget or time.* **Mitigation:** Use Agile iterative development to deliver core value early (minimum viable product) so that if later features slip, the most important capabilities are already delivered. Regularly monitor burn rate and progress; if we see slippage by mid-project, either de-scope lower priority features (per scope section) or secure additional budget/time from stakeholders by presenting a justified case.

Prerequisites:

* Conduct a risk workshop with the team and possibly stakeholders to brainstorm what could go wrong. Many risks might have been mentioned already in meetings or earlier sections (assumptions often point to risks if wrong).
* Use organizational knowledge: e.g., check past similar projects for typical risks (maybe adoption was an issue before, or integration took longer, etc.).
* Identify existing **mitigation plans** or strategies from company best practices (for example, the company might always do a pilot to mitigate user adoption risk – include that).
* Ensure you have management support for the mitigation actions that require resources (like extra training sessions, load testing infrastructure, etc.).

### Standards and Best Practices

Proactively listing risks in a PRD underscores a culture of planning and quality. Agile methodologies encourage addressing risks early (spikes, proof-of-concepts to mitigate technical risks). Traditional PM frameworks (PMBOK) have entire processes for risk management; summarizing the top risks in this doc means they’re visible to all stakeholders reading it. It’s noted that a good PRD can also act as a tool for **risk mitigation** by identifying challenges early. Many successful teams use the PRD review as a chance to discuss “what could go wrong” – capturing those results here. While the PRD is mainly about requirements, including a risk section (especially for an internal critical project) is considered a best practice by many product leaders to ensure everyone is mindful of challenges ahead. The goal is to reduce the likelihood of surprises later, thereby avoiding costly delays or failures.

## Open Questions / Issues Log

#[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Track unanswered questions and pending decisions so that nothing critical is
overlooked and owners are accountable for resolution.

#Instructions:

1. Maintain a rolling list with ID, Question, Owner, Needed‑by Date, Status.
2. Review at each sprint planning or stakeholder meeting.
3. Promote resolved items to assumptions, requirements, or risks sections as
    appropriate.
4. Archive closed questions to keep the list concise.

#Example:

| **ID** | **Question**                                            | **Owner**     | **Needed-by** | **Status**     |
|--------|---------------------------------------------------------|---------------|---------------|----------------|
| Q-01   | Will field techs require electronic signature capture?  | Ops Mgr.      | 2025-07-12    | OPEN           |
| Q-02   | Can we reuse existing ArcGIS licence seats?             | GIS Lead      | 2025-07-05    | ANSWERED — Yes |
| Q-03   | What is the maximum photo size supported by Maximo API? | Vendor Rep    | 2025-07-18    | PENDING        |
| Q-04   | Does Legal approve storing limited PII on tablets?      | Legal Counsel | 2025-07-25    | OPEN           |

#Prerequisites:

* A facilitator (Product Mgr.) to curate and chase answers.
* Agreement from stakeholders to supply timely responses.

#Standards & Best Practices:

PMBOK issue‑log practice; Agile “parking lot” technique; RACI for ownership
clarity.

## Supporting Materials

### Appendix & References

#[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To provide any additional information, supporting materials, or references to external documents that are relevant to the PRD. This section ensures that readers can find further details or source materials if needed, without cluttering the main sections. It can include glossaries, detailed data, or links to other documents like design specs or regulatory texts.

#Instructions:

* **References:** List documents, web links, or resources that were used as inputs for this PRD or that the reader might consult for more information. This may include:
  * Related requirement documents (e.g., a higher-level Market Requirements Document if one exists, or a Vision & Scope document).
  * Technical specifications or API documentation for systems we integrate with (e.g., “Maximo WMS API Guide, version 1.2”).
  * Corporate policies or standards referenced (e.g., “IT Security Policy Manual, rev 2025” or “UI Style Guide v3”).
  * Regulatory documents (e.g., “NERC CIP standards version X” or “CPUC General Order for record-keeping”).
  * User research or survey results if any (maybe a summary report of a field user survey that influenced requirements).
  * Any external standards (ISO, IEEE) or industry guidelines that were referenced.
* For each reference, provide enough detail for someone to find it: title, version/date, and where/how to access it (a URL or repository path, etc.), as per standard practice. If it’s an internal doc not broadly accessible, note the contact or location.
* **Glossary:** (if applicable) Define any abbreviations, acronyms, or domain-specific terms used in the PRD. For a utility, acronyms like “WMS (Work Management System)”, “GIS (Geographic Information System)”, “NERC CIP”, etc., may need explanation. List each term with a brief definition. This is very helpful for new team members or stakeholders not familiar with all jargon.
* **Additional Details:** You can include any supplementary details that didn’t fit in main sections. For example, detailed tables, or raw data that support a requirement. E.g., a table of user roles and permissions (if not already covered), or a copy of a survey result chart, etc. Keep in mind the medium – if this is Markdown text, large tables may be a bit unwieldy; consider if it’s better as a separate document.
* **Design Artifacts:** If wireframes, mockups, or process flow diagrams exist, list them here (or link to them). E.g., “See Wireframe\_v1.pdf for preliminary UI design of the mobile app.” In an online documentation system, you might embed images or links. (Ensure these are accessible to the team).
* Clearly separate each part (you can use subheadings within Appendix if multiple types of info, like “Glossary” as a sub-section).

#Example:

**References:**

* *Utility Mobile App Survey Results* – Analysis report of field technician survey, PowerCo UX Team, March 2025. (Available on the internal SharePoint: `\\Company\Research\FieldSurvey2025.pdf`)
* *Maximo Work Management System – API Documentation v1.2* – Provided by Maximo vendor, June 2025. (Internal Confluence page “Maximo API Guide”).
* *IT Security Policy Manual* – Rev. 2025, Section 5.2 “Mobile Device Security Requirements” used for encryption/password policies.
* *NERC CIP Standards* – NERC CIP-003 through CIP-011 (Version 5) guidelines for cyber security of BES Cyber Systems. Relevant portions (like CIP-007 Logging) were referenced. Official documentation is available on NERC’s website.
* *IEEE 830-1998 SRS Standard* – Used for general guidance on good requirements practices (e.g., qualities of requirements).
* *ISO/IEC 25010:2011 (Software Product Quality)* – Referenced for defining quality attributes categories.
* *Corporate UI Style Guide* – “PowerCo Digital Style Guide v3”, June 2024, by UX Team (contains design standards for internal apps).
* *Project Charter: Field Service App* – Initial project charter approved Jan 2025 (includes high-level budget, initial scope outline).

**Glossary:**

* **PRD:** Product Requirements Document. This document outlining product requirements.
* **WMS:** Work Management System. The existing system (Maximo) that manages work orders, which the new app will interface with.
* **GIS:** Geographic Information System. Used to provide mapping and geolocation services (e.g., showing work order locations).
* **NERC CIP:** North American Electric Reliability Corporation’s Critical Infrastructure Protection standards – rules that govern cybersecurity for the electric grid.
* **CIP-007:** A specific NERC CIP standard dealing with system security management (mentioned in context of logging and patch management).
* **CPUC:** California Public Utilities Commission – state regulator that may set requirements our utility must follow.
* **MFA:** Multi-Factor Authentication – a security measure requiring multiple forms of verification to log in.
* **UAT:** User Acceptance Testing – a phase where end users test the system to ensure it meets their needs before full deployment.
* **MVP:** Minimum Viable Product – a version of the product with just enough features to be usable and deliver value, used to gather feedback for improvement.
* **INVEST:** A mnemonic for good user stories (Independent, Negotiable, Valuable, Estimable, Small, Testable).

**Additional Notes:**

* **Future Enhancements:** (Optional to note) Some features considered out-of-scope now could be revisited later. E.g., integration with Inventory System for parts tracking is a potential Phase 2 item. Stakeholders have expressed interest, so though it’s out-of-scope, it remains in the backlog for future discussion.
* **Decision Log:** (Optional) Significant decisions made during requirements development (like choosing an on-prem solution vs cloud, or deferring a certain feature) are documented in the project’s decision log, referenced here for completeness (See Confluence page “FieldApp Decisions”). This helps anyone reading the PRD understand why certain choices were made if there’s ever confusion.

#Prerequisites:

* Ensure all documents and resources referenced are accessible to the team (permissions in place).
* Double-check that acronyms used throughout the PRD are captured in the glossary.
* Review if any content was deferred from main sections to appendix (for example, if you had a very detailed table that didn’t fit nicely in a section, make sure it’s attached or referenced here).

#### Standards and Best Practices

Including references in a requirements document is part of IEEE recommendations – it provides traceability to source materials and clarifies the basis of requirements. A glossary is highly recommended by many technical writing standards to ensure common understanding, especially in cross-functional teams (it prevents confusion over terms and acronyms). By following this approach, the PRD remains focused yet doesn’t lose important supplementary information. International standards for documentation (like ISO/IEC/IEEE 26513 for documentation) encourage providing references and glossaries for completeness. This section will help new team members or auditors (if they ever review the requirements) to find background information and understand domain-specific language used in the PRD.

Prompt

139,121 characters

# Product Requirements Document Workflows

Choose the operation from the user's request. Use the shared template below for all three operations.

- **Create:** Gather the supplied documents and missing requirements, then draft the PRD. The creation instructions below govern this mode.
- **Quality review:** Compare the supplied PRD against each template section. Use a six-point quality scale with Excellent and Unacceptable as endpoints, stating the intermediate labels used. Rate clarity and completeness on Exceeds Expectations, Meets Expectations, or Does Not Meet Expectations. Recommend one of: Approved as-is to proceed to human review, Approved with Minor Revisions, or Unapproved with Major Revisions. These are review recommendations, not actual approvals. For each gap give the feedback item, plain-language impact, corrective action, priority, and an explicitly estimated time to fix; use TBD when there is no basis for an estimate.
- **Impact analysis:** Assess supplied review findings or a proposed change against affected requirements, scope, dependencies, risks, delivery phases, and operating responsibilities. Link each impact to evidence. Keep unknown owners, dates, and estimates as TBD and distinguish proposed action from an agreed commitment.

For review and impact analysis, return the requested assessment instead of a newly filled PRD. Rules that require only filled section content apply to creation mode. Never turn template examples into project facts. Preserve the attachment citations, measurable metric baselines and instrumentation owners, anti-goals, release gates, and open-question tracking relevant to the requested operation.

## Creation Mode

You are a Senior Product Owner writing a Product Requirements Document (PRD) for
an internal utility company software product.

## Inputs
- You will be given one or more attached documents as source material.
- Treat attachments as the primary source of truth.

## Creation Rules
- Purpose, Instructions, Examples, Prerequisites, and Standards and Best Practices are NOT part of the final output.
- Output ONLY the requested section content.
- Do NOT restate instructions or explain reasoning.
- If required information is missing, write "TBD".
- Maintain executive-appropriate tone and clarity.
- Follow each section’s rules independently.



## Output rules (IMPORTANT)
1. Produce a PRD using the the template below.
2. Output ONLY the filled PRD content for each section (do NOT include the
  template’s “Purpose/Instructions/Example/Prerequisites/Standards” text).
3. Do NOT invent facts. If information is missing, write “TBD” and add a
  corresponding entry to the Open Questions / Issues Log.
4. Where possible, cite the source attachment for key facts (format: [DocName – section/page or heading]).
5. If attachments conflict, document the conflict explicitly in Assumptions &
  Dependencies and add an Open Question to resolve it.

## Process
Phase 1 — Clarifying Questions (single batch)
- Ask up to 20 questions total, prioritized and communicated to the user as:
  - Blocking (must answer to complete PRD)
  - Important (improves accuracy)
  - Optional (nice-to-have)
- Present questions in a table: Priority | PRD Section | Question | Why it
  matters | What a good answer looks like.

Phase 2 — Draft PRD
- After receiving answers, produce the complete PRD.
- Keep the PRD concise (target 8–15 pages equivalent).
- Include Gherkin acceptance criteria ONLY for the most critical user scenarios.
  For the rest, use bullet acceptance criteria.

## Requirement conventions
- Functional requirements: FR-001, FR-002, …
- Non-functional requirements: NFR-001, NFR-002, …
- Security/compliance requirements: SEC-001, SEC-002, …
- Data governance rules: DG-001, DG-002, …
- Include a traceability matrix mapping Objectives → Scenarios → Requirements.

## PRD Template

```markdown
# Product Requirements Document (PRD)

## Document Information & Revision History

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose: To record key document details (project name, version, date, authors) and track changes over time. This section ensures everyone is referencing the correct version and understands what has changed. It provides transparency and accountability for document updates.

Instructions:
* List the **Project/Product Name**, a brief description or subtitle if needed, the **Document Version**, date of creation or update, and the **Author(s)** or owner of the PRD.
* Include a **Revision History** table or list, logging each significant update: version number, date, author, and a short description of changes.
* Optionally, note the document status (Draft/Approved) and any required approvals or sign-offs by stakeholders. For example, in Waterfall environments you might require formal approval of the PRD before development.

Example:
* *Title:* **Field Service Mobile App PRD**
* *Version:* 1.0 (Draft)
* *Date:* June 10, 2025
* *Author:* Jane Doe (Product Manager)
* *Approvals:* John Smith (IT Director) – Pending
* *Revision History:*

  * **v0.1** – 2025-06-01 – J. Doe – Initial draft created.
  * **v0.2** – 2025-06-05 – J. Doe – Updated scope and added user personas after stakeholder review.

Prerequisites:
* A clear **product/project name** and designation of a product owner or author.
* Initial agreement on the project’s existence/approval so that version 1.0 of the PRD can be drafted.
* Defined process for document review and approval (know who needs to approve or be informed of changes).

Standards and Best Practices:
It is best practice to include a revision history in requirement documents for traceability. For example, IEEE recommends recording changes with version, date, author, and reason for changes in the SRS/PRD. This aligns with ISO/IEC documentation standards and helps maintain a “single source of truth” for the product definition.
[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Executive Summary

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Provide a **one-page, executive-friendly** snapshot of the product that answers:
- **What problem are we solving?**
- **For whom?**
- **What solution are we delivering (at a high level)?**
- **How will we know early if we’re on track (leading indicators)?**
- **How will we measure success (success metrics)?**
- **What is in scope vs. not (scope summary)?**

This section is designed for fast stakeholder alignment, onboarding new team members, and ensuring the PRD has a clear “north star” before diving into details.

Instructions:

Include the following subsections (keep each concise—aim for 3–8 bullets each):

1. **Problem / Opportunity**
  - State the core business problem and why it matters now.
  - Include 1–2 concrete symptoms (e.g., delays, rework, compliance findings).
  - If applicable, name the driver: operational efficiency, safety, regulatory requirement, cost reduction.

2. **Target Users**
  - Identify primary and secondary user groups (job roles).
  - Note environment constraints (field/office, offline, device limitations).

3. **Proposed Solution**
  - Describe the product at a high level (what it does, not how it’s built).
  - Mention primary workflows supported.
  - Identify “system of record” boundaries at a high level (if relevant).

4. **Leading Indicators (Early Signals)**
  - Metrics that indicate adoption and product health **before** long-term outcomes are realized.
  - Examples: activation rate, weekly active users, sync success rate, task completion rate, reduction in support tickets.
  - Include baseline (if known), target, and measurement window (e.g., first 30/60/90 days).

5. **Success Metrics (Outcomes / KPIs)**
  - Define the major outcomes tied to business value (efficiency, compliance, quality).
  - Use SMART framing: baseline → target → by when.
  - Name measurement owners and data sources at a high level.

6. **Scope Summary**
  - Bullet the top “in-scope” items for this PRD (MVP/Release 1).
  - Bullet the top “explicitly not included” items (or reference the “Out of Scope / Anti-Goals / Future Ideas” section).

**Formatting guidance**
- Keep it skimmable.
- Prefer bullets and small tables.
- Avoid implementation detail (save that for Architecture/Technical sections).
- If information is unknown, mark **TBD** and add to the Open Questions log.

Example:

**Problem / Opportunity**
- Field technicians currently complete work orders using paper forms and later re-enter data into the Work Management System (WMS), causing:
  - 1–2 day delays in work order closure visibility
  - data entry errors and missing compliance evidence (photos, timestamps)
- Recent internal audits flagged inconsistent record completeness and delayed reporting for maintenance activities.

**Target Users**
- Primary: Field Technicians (daily usage; often offline; gloves/sunlight constraints)
- Secondary: Field Supervisors (monitoring/assignment; office + field)
- Supporting: IT Support/Admin, Compliance/Regulatory Affairs

**Proposed Solution**
- A Field Service Mobile App + Supervisor Web Dashboard that enables:
  - viewing and updating assigned work orders in the field
  - capturing required evidence (photos/notes/timestamps)
  - offline queueing with reliable sync back to WMS
- WMS remains system of record for work orders; the product is a system of entry for field execution updates.

**Leading Indicators (first 30–90 days post-launch)**
| Indicator | Baseline | Target | Measurement Window | Data Source | Owner |
|---|---:|---:|---|---|---|
| Technician activation rate (% who complete first work order digitally) | TBD | ≥ 80% | 30 days | App event logs + WMS status | Product Owner |
| Weekly active technicians | TBD | ≥ 70% of licensed users | 60 days | App analytics | Ops Analytics |
| Offline sync success rate | TBD | ≥ 99% | 30 days | Sync logs | Engineering Lead |
| Support tickets per 100 users | TBD | ≤ 5 | 90 days | ITSM tool | IT Support Lead |

**Success Metrics (6–12 months)**
| Outcome KPI | Baseline | Target | Timeframe | Data Source | Owner |
|---|---:|---:|---|---|---|
| Avg. work order completion-to-close time | 2 days | 1 day | 6 months | WMS timestamps | Ops Analytics |
| Data entry error rate (maintenance logs) | TBD | -90% | 6 months | Data quality checks | Data Steward |
| Compliance evidence completeness (% with required fields + timestamp + photo where required) | TBD | 100% | 12 months | WMS + audit package | Compliance Lead |

**Scope Summary**
- In scope (Release 1): Assigned work orders, status updates, offline queue + sync, photo capture, supervisor dashboard, role-based access control, audit logging.
- Not included: inventory management, predictive analytics, customer-facing outage reporting (see “Out of Scope / Anti-Goals / Future Ideas”).

Prerequisites:

- A clear problem statement validated with business stakeholders (Operations, Compliance).
- Identified primary user roles and their operating context (devices, connectivity).
- Initial agreement on expected outcomes and how success will be measured (even if baselines are TBD).
- Agreement on MVP boundaries (what is “Release 1” vs later).

Standards & Best Practices:

- **“One-page narrative” discipline:** An executive summary should be readable in <5 minutes.
- **Outcome-first framing:** Start with the problem and outcomes, then features.
- **Leading indicators vs lagging outcomes:** Track adoption/health early; business value later.
- **SMART metrics:** Baseline + target + timeframe, with named owners and data sources.
- **Consistency with PRD traceability:** Executive Summary KPIs should map to Objectives and Success Metrics sections later in the PRD.
[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Project Background & Overview

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose: To provide context and a high-level summary of the product. This section explains *why* the project is being undertaken and *what* the product is, ensuring readers understand the problem being solved and how the product fits into the utility’s business strategy or operations.

Instructions:

* **Background/Problem Statement:** Describe the business problem, opportunity, or regulatory driver that led to this project. Include relevant context about the current state (e.g. “field technicians currently use paper forms, leading to delays”). Relate the initiative to the utility’s goals or mandates (for example, improving grid reliability or meeting a new regulatory requirement).
* **Project Overview:** Summarize the proposed solution at a high level – what the product will do and who it serves. Keep it concise (a few sentences) and focused on the essence of the product. Make sure to address *why* the solution is needed (the justification). For instance, mention if this product replaces or enhances an existing system, or if it’s a new capability.
* **Strategic Alignment:** (Optional) Briefly note how the project aligns with corporate objectives or industry trends (e.g., supports renewable integration, improves customer service, complies with new California regulations). This helps stakeholders see the big picture.

Example:

*Background:* Field technicians at our utility currently rely on paper work orders and manual data entry, causing delays and data errors. Regulatory audits (e.g., CPUC reporting) have highlighted inefficiencies in our maintenance tracking.

*Overview:* The **Field Service Mobile App** project will create a mobile application for field crews to receive work orders, document maintenance tasks, and synchronize data with the central system in real-time. This solution addresses the manual process inefficiencies by digitizing work orders, improving data accuracy and timeliness. It aligns with PowerCo’s strategic goal of operational excellence by streamlining field operations and supports California’s regulatory push for better outage response tracking.

Prerequisites:

* Gather background information from business stakeholders (e.g. operations managers, regulatory reports) to clearly define the problem.
* Understanding of any **regulatory or business mandates** driving the project (for a California utility, this could be CPUC requirements, reliability standards, etc.).
* High-level agreement on the solution concept (e.g., confirmed that a mobile app is the chosen approach to solve the problem).

### Standards and Best Practices

It’s recommended to clearly articulate the product’s purpose and the problem it solves. For example, a PRD should briefly describe what the project is about and *why* you are doing it. Additionally, IEEE guidelines suggest relating the software’s objectives to corporate goals or business strategies when applicable. This ensures the PRD provides context linking the product to organizational strategy and needs.

[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]

## Objectives & Success Metrics

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To define what the product aims to achieve (the objectives) and how success will be measured. This section translates the project’s vision into specific, measurable goals. It ensures that everyone knows the target outcomes and how they will be evaluated, providing clear success criteria for the product.

Instructions:

* List the **key objectives or goals** of the product. Objectives should be written as outcomes (what will be improved or achieved). They can include business outcomes (e.g., cost savings, efficiency gains), user outcomes (e.g., improved user satisfaction), or system outcomes (e.g., decommissioning legacy systems).
* For each objective, define one or more **success metrics or Key Performance Indicators (KPIs)** that will indicate whether the objective is met. Use the SMART criteria for goals: make metrics Specific, Measurable, Achievable, Relevant, and Time-bound. For example, if an objective is to improve field work efficiency, a metric might be “reduce average work order completion time by 30% within one year.”
* Be clear on the baseline and target values for metrics if known. If the objective is regulatory compliance, the success metric could be simply meeting the compliance by a certain date or passing an audit.
* Be sure to include information on who will be responsible for tracking these metrics post-launch (e.g., operations team, product manager).
* Be sure to include when they will be measured (e.g., 3 months after launch, 6 months after deployment).
* Be sure to include what system or tools will do the measurement (e.g., analytics dashboard, manual audit).
* Be sure to include a baseline for comparison (e.g., current error rate, current processing time).
* Optionally, distinguish between **primary metrics** (most critical to success) and secondary metrics. You can also indicate the timeframe for achieving each metric (e.g., by end of Q4 2025).

Example:

* **Objective 1:** Improve field operation efficiency.

  * **Success Metric:** Reduce average work order processing time from 2 days to 1
    day (50% improvement) within the first 6 months of deployment.

  * **Metric Instrumentation Plan:** Average work order processing time (2 days → 1 day
    within 6 months)

    * **Data source:**

      * Work Management System (WMS) timestamps (Created Date, Assigned Date,
        Completed Date)
      * Mobile app event logs (optional secondary source for workflow timing)
    * **Owner:**

      * Operations Analytics Lead (primary)
      * Product Manager (accountable for reporting out)
    * **Measurement cadence:**

      * Weekly monitoring (trend + outliers)
      * Monthly reporting (official metric for stakeholder reviews)
    * **Sunset criteria (when this metric stops mattering):**

      * Sunset after the metric remains at or below **1.0 day average** for **3
        consecutive months**, *and* the product moves from “adoption” into “steady
        state operations.”
      * After sunset, replace with a “sustainment” metric (e.g., % work orders
        completed within SLA) if needed.

* **Objective 2:** Enhance data accuracy and reporting.

  * **Success Metric:** Achieve at least a 90% reduction in data entry errors in
    maintenance logs (measured by comparing error rates before and after app
    rollout).

  * **Metric Instrumentation Plan:** Data entry error rate reduction (target ≥ 90%
    reduction)

    * **Data source:**

      * Maintenance log validation reports (required-field completeness, invalid
        values, duplicate entries)
      * Data quality dashboards in BI tool / reporting layer
      * Sample-based QA audits (manual review of a statistically relevant sample,
        if available)
    * **Owner:**

      * Data Quality Manager (primary)
      * Reporting/BI Lead (supports instrumentation + dashboards)
    * **Measurement cadence:**

      * Bi-weekly automated data quality checks
      * Monthly QA sampling and formal metric readout
    * **Sunset criteria (when this metric stops mattering):**

      * Sunset after error rates stabilize and remain within the agreed threshold
        (i.e., **≥ 90% improvement**) for **2 consecutive quarters**, *and* there
        are no major form/schema changes planned.
      * Reactivate temporarily after any major release that changes data capture
        fields or validation rules.

* **Objective 3:** Increase regulatory compliance and audit readiness.

  * **Success Metric:** 100% of required maintenance activities are digitally
    recorded and time-stamped, producing audit reports that meet California
    regulatory standards by the end of 2025.

  * **Metric Instrumentation Plan:** % of required maintenance activities digitally
    recorded + audit readiness (target 100%)

    * **Data source:**

      * WMS compliance fields and completion timestamps
      * Immutable audit logs (system log store / SIEM / audit log service)
      * Generated audit reports and audit evidence packages (export logs, change
        history, user actions)
    * **Owner:**

      * Compliance Officer / Regulatory Affairs Lead (primary)
      * System Owner for WMS (accountable for system-of-record compliance data)
    * **Measurement cadence:**

      * Weekly compliance exception review (missing timestamps, incomplete
        required fields)
      * Quarterly internal audit readiness check (evidence package + report
        generation test)
      * Pre-audit validation as needed (triggered by scheduled audits)
    * **Sunset criteria (when this metric stops mattering):**

      * This metric generally does **not fully sunset** while regulations apply;
        instead it transitions to “business-as-usual compliance monitoring.”
      * If a sunset is required: sunset the “implementation” version once the org
        has passed **one full audit cycle** using the new digital records with
        **zero critical findings** attributable to the product, then replace it
        with an ongoing KPI (e.g., # compliance exceptions per month, time to
        remediate exceptions).

Prerequisites:

* Baseline data for current performance (to have something to measure against, e.g., current average processing time, current error rate).
* Clarity on business priorities – know which outcomes are most valued (e.g., is speed more important than cost, or is compliance the top priority?).
* Input from stakeholders on what success looks like (executives, department heads, or regulatory affairs might define success differently).

### Standards and Best Practices

Goals and metrics should be concrete. It is best practice to use the **SMART principle** for setting goals: make them Specific, Measurable, Achievable, Relevant, and Time-bound. Tying product features to these success metrics ensures each requirement contributes to business value. For example, instead of a vague goal like “improve efficiency,” specify a measurable target. Product management literature emphasizes defining success metrics to indicate you’re achieving the internal goals for the project. This practice aligns with both agile OKR (Objectives and Key Results) approaches and traditional project management.

[END SECTION INSTRUCTIONS]

[SECTION OUTPUT TEMPLATE]
{{What the final content should look like, WITHOUT guidance text}}

[END SECTION OUTPUT TEMPLATE]


## Scope of Work

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To clearly delineate what features and work are included in this product (in scope) and what is explicitly excluded (out of scope). Defining scope prevents misunderstandings and “scope creep” by setting boundaries around the product. This section ensures the development team and stakeholders have a common understanding of what will (and will not) be delivered.

Instructions:

* **In Scope:** List the functionalities, features, and components that *will* be part of the product. Be as specific as necessary to set clear expectations. This can be a bullet list. Group them if helpful (for example, “Core Features,” “Integration Points,” “Reporting capabilities,” etc.).
* **Out of Scope:** List any known features or tasks that people might assume would be included but *will not* be delivered as part of this product. It’s important to call these out to avoid future disputes. Also mention if certain requests will be deferred to a later phase or handled by another system.
* Optionally, provide a brief **justification** or note for major exclusions (“why out of scope”) – e.g., “Feature X is out of scope for this release due to regulatory constraints or because it will be handled in a separate project.”
* If using a MoSCoW prioritization (Must, Should, Could, Won’t have), you can integrate that here: “Won’t have” items would be out of scope. Must/Should could be considered in-scope with priority tags. (This is optional but can be useful for internal prioritization.)

Example:

* **In Scope:**

  * Mobile application features for viewing and updating work orders (create, edit, complete work orders).
  * Integration with the existing Work Management System (WMS) to fetch and update work order data.
  * GIS map view to show the location of jobs and nearest assets (for field navigation).
  * Basic reporting dashboard for supervisors to see work order status in real time.
* **Out of Scope:**

  * *Customer-facing features* – The app will be used by internal field staff only; no customer mobile app features (e.g., outage reporting by customers) are included.
  * *Inventory management* – Tracking spare parts or inventory is not included in this PRD; it is handled by a separate inventory system.
  * *Legacy device support* – Supporting devices older than Android 8/iOS 13 is out of scope due to security policy (users will be provided with updated devices).
  * *Future Phase Features* – Advanced analytics for predictive maintenance (planned for a later phase, not included in initial release).

Prerequisites:

* Alignment with stakeholders on overall **project boundaries** (ensure everyone had input on what’s included). Often this comes from initial project charter or business case.
* A high-level feature brainstorming or requirements gathering session, where potential features were identified and then pruned or phased – providing the raw input to define in vs. out of scope.
* Awareness of **dependencies or separate projects**: knowing if some features are being handled by other teams or future projects (so you can mark them out of scope here).

### Standards and Best Practices

Explicitly listing what is *not* being done is as important as listing what is. Industry templates often include a “Features Out” or “Exclusions” section to capture this. Clearly documenting out-of-scope items (and reasons if helpful) is recommended by product management best practices to manage stakeholder expectations. This practice helps maintain focus and avoid scope creep. Additionally, in formal methodologies (like PMI’s PMBOK), scope definition is a key step – including delineation of project boundaries and exclusions. Using visual aids (like a scope diagram or a MoSCoW prioritization chart) can also be helpful, though not mandatory.

## Release Plan / Phasing

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Define how the product will be delivered over time in **phases** (e.g., MVP, Pilot, GA, Phase 2) to:
- anticipate and manage **scope negotiation**
- align stakeholders on what ships **when**
- ensure **incremental value delivery**
- reduce risk via pilots, staged rollouts, and decision gates

This section is not a detailed project plan; it is the product’s **intentional sequencing strategy**.

Instructions:

1. **Define the release philosophy**
  - Example: “Pilot-first,” “MVP-first,” “feature flags,” “regional rollout,” “progressive enablement.”
  - State how you will manage change requests (trade-offs, governance).

2. **List the phases**
  - Common phases:
    - Discovery / Validation (optional)
    - MVP Build
    - Pilot (limited users/region)
    - General Availability (GA)
    - Phase 2+ Enhancements
  - For each phase, document:
    - Goal / value delivered
    - Target user group and rollout size
    - Key capabilities included (at an epic level)
    - Exit criteria (what must be true to progress)
    - Key dependencies and risks
    - “Not in this phase” callouts (top 3–5)

3. **Add explicit scope negotiation rules**
  - Define how scope changes are handled:
    - If new requirements appear, what gets traded off?
    - Who decides (decision authority)?
    - What is the “MVP protection rule” (e.g., don’t endanger pilot readiness)?

4. **Add decision gates**
  - For example:
    - “Pilot Go/No-Go”
    - “GA Readiness”
    - “Expand to Region B”
  - Define required evidence: usability results, security sign-off, performance test results, operational support readiness.

5. **Optional: include a simple timeline**
  - If dates are unknown, use relative quarters/months or “TBD.”

**Formatting guidance**
- Use a table for phases.
- Keep features at “epic” level (avoid detailed user stories here).
- If uncertain, mark **TBD** and capture in Open Questions.

Example:

**Release approach**
- Deliver MVP to a pilot group of technicians in one region with staged enablement and feature flags.
- Expand to GA only after meeting usability, reliability, and compliance exit criteria.

**Phasing table**
| Phase | Goal | Users / Rollout | Included Capabilities (Epics) | Exit Criteria | Not Included / Deferred |
|---|---|---|---|---|---|
| 0 — Discovery (4–6 wks) | Validate workflows + constraints | SMEs + 5 techs | Journey mapping, prototype, data/SoR decisions | Signed workflow + measurement plan | Full reporting suite |
| 1 — MVP Build | Deliver core field execution | Dev/test env | Work order list/detail, status updates, offline queue, photo capture, SSO/RBAC | Security threat model complete; MVP UAT pass | Advanced analytics |
| 2 — Pilot | Prove adoption + reliability | 1 region / 25 techs | MVP + supervisor dashboard + audit exports | ≥80% activation; ≥99% sync success; no Sev 1/2 defects | Inventory integration |
| 3 — GA | Company-wide operational use | All target regions | Hardened MVP + support model + monitoring | Ops support readiness; compliance sign-off; performance tests passed | Predictive maintenance |
| 4 — Phase 2 | Expand value | Targeted | Enhanced reporting, integrations, workflow improvements | Approved roadmap + funding | Customer-facing features |

**Scope negotiation rules**
- Any new “must-have” requirement added after Pilot start must trade off:
  - another “must-have” item of similar effort **or**
  - pilot date/rollout scope
- Decision authority:
  - Product Owner: backlog priority and trade-offs
  - Sponsor: budget/schedule changes
  - Security/Compliance: mandatory controls (non-negotiable)
- “MVP protection rule”: do not add features that increase training time or reduce offline reliability without explicit sponsor approval.

Prerequisites:

- Agreement on MVP definition and business priorities (what must ship first).
- Identified rollout constraints (regions, devices, training capacity, support coverage).
- Security/compliance gating expectations (what must be approved before pilot/GA).
- High-level dependency awareness (WMS API readiness, GIS availability, device rollout timing).

Standards & Best Practices:

- **Incremental delivery:** Favor small releases that deliver value and reduce risk.
- **Pilot-first for operational tools:** Validate usability, offline behavior, and support load in a controlled rollout.
- **Exit criteria-based gating:** Advance phases based on measurable readiness, not optimism.
- **Explicit scope trade-off model:** Scope changes require transparent trade-offs (scope/time/cost).
- **Use prioritization frameworks:** MoSCoW (Must/Should/Could/Won’t) or similar methods to make negotiations concrete.
- **Operational readiness matters:** GA is not just features—it includes support, monitoring, training, and incident response readiness.

## Out of Scope / Anti-Goals / Future Ideas

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Create clear boundaries and guardrails by distinguishing:
- **Out of Scope** (not included in this PRD/release, may be considered later)
- **Anti-Goals** (explicit directions the product is not intended to pursue)
- **Future Ideas** (uncommitted concepts worth tracking for later discovery)

This section prevents “silent expansion” of product intent, reduces scope creep, and enables consistent decision-making when new requests emerge.

Instructions:

#### 1) Provide clear definitions (required)

- **Out of Scope**
  - Items stakeholders might expect, but are **not included** in the current delivery.
  - May be considered in later phases, but not committed.

- **Anti-Goals**
  - Deliberate guardrails: directions the product should **actively avoid**.
  - Not “later”—instead “not this product” unless strategy changes.

- **Future Ideas**
  - Candidate enhancements or adjacent opportunities with **no current commitment**.
  - Often require discovery, funding, or strategy review before becoming roadmap items.

#### 2) Classify items using a structured list or table

For each item include:
- Item description
- Category (Out of Scope / Anti-Goal / Future Idea)
- Rationale (“why”)
- Revisit trigger (what must change to reconsider)
- Owner (who evaluates it)

#### 3) Tie to decision-making

- If a request conflicts with an **Anti-Goal**, require a product strategy escalation (not normal backlog prioritization).
- If a request is **Out of Scope**, confirm whether it belongs to a future phase or another team/system.
- If it is a **Future Idea**, capture it for discovery without promising delivery.

Example:

**Definitions**
- Out of Scope = not delivered in Release 1; might be Phase 2+.
- Anti-Goal = not a direction for this product.
- Future Idea = parked hypothesis or enhancement concept.

**Classification table**
| Item | Category | Rationale | Revisit Trigger | Owner |
|---|---|---|---|---|
| Inventory/parts tracking inside the field app | Out of Scope | Handled by existing inventory system; avoid expanding MVP | Sponsor approves Phase 2 funding + integration plan | Product Owner |
| Replace the Work Management System (WMS) | Anti-Goal | WMS remains system of record; replacement is a separate program | Executive strategy change + funding program | Sponsor |
| Advanced predictive maintenance analytics embedded in the app | Anti-Goal | Belongs in analytics/BI platform; requires governance + data science | Separate analytics initiative launched | Data/Analytics Lead |
| Contractor-facing access to work orders | Out of Scope | Requires vendor identity model + policy review | Security approves external access model | Security Lead |
| Voice-to-text for notes | Future Idea | Potential usability win; needs field testing + device policy validation | Usability study shows typing is a major blocker | UX Lead |
| Integration with outage management notifications | Future Idea | Could improve coordination; requires OMS alignment | OMS roadmap includes API availability | Ops Systems Owner |

Prerequisites:

- Agreement on the product’s intended “job to be done” and boundaries (what system it is, what it isn’t).
- Awareness of adjacent systems and owners (WMS, GIS, Inventory, BI, OMS) to avoid duplication.
- Stakeholder input on common assumption traps (“people will expect X”).

Standards & Best Practices:

- **Non-goals are first-class requirements:** Treat them as guardrails that shape decisions.
- **Prevent duplication of systems of record:** Especially important in regulated utility environments.
- **Make “no” explainable:** Always include rationale and revisit triggers to reduce friction.
- **Separate “deferred” from “never”:** Out of Scope ≠ Anti-Goal.
- **Use as a governance tool:** Anti-goals should trigger escalation and documented strategy decisions.

## Stakeholders

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To identify all the key stakeholders of the product – the individuals or groups who have a vested interest in its success or are affected by its outcome. This section ensures that everyone who needs to be involved or informed is recognized, and their roles are clear. It helps in communication planning and in validating requirements against stakeholder needs.

Instructions:

* Provide a **list of stakeholders** and their roles/interest in the project. Stakeholders can include:

  * **Business Owners/Sponsor:** e.g. VP of Operations or Department Head funding or championing the project. They care about high-level outcomes (efficiency, ROI, compliance).
  * **Product Owner / Product Manager:** (if different from author) who is responsible for product decisions.
  * **Development Team:** This could be represented by the Engineering Manager or Tech Lead. (While the whole dev team uses the PRD, listing the lead is useful.)
  * **Users or User Representatives:** Sometimes a key user or a user group representative is considered a stakeholder (overlaps with personas but here we might list the user community’s representative, like “Field Operations Team”).
  * **Other Internal Stakeholders:** This could include IT Security (concerned with cybersecurity requirements), Compliance Officer (for regulatory needs), UX/UI Designer, Quality Assurance lead, DevOps/IT Infrastructure (if deployment environment is their concern), and any supporting departments like Training or Customer Service (if they will support the product).
  * **External Stakeholders:** If any external entities are involved (e.g., a vendor or a regulatory body) list them too. For internal products, external stakeholders might be minimal, but for example “Consultant from Company X assisting with integration” or “Auditor (external) will review compliance after launch” could be relevant.
* For each stakeholder or group, you may include a short note on their **interest or contribution**. For example: “IT Security Team – will review the app for compliance with cybersecurity standards.” This helps to understand why they matter.
* Ensure you identify who has **decision-making authority** among stakeholders (for example, sponsor approves budget/scope changes, IT Security must sign off on compliance, etc.), though detailed RACI matrix is optional.

Example:

* **Project Sponsor:** Jane Smith – Director of Field Operations (Champion for the project, provides budget and ensures project aligns with operational improvement goals).
* **Product Manager:** John Doe – IT Product Manager for Field Systems (Owns the PRD, coordinates stakeholder input, responsible for delivering business value).
* **Development Team Lead:** Alice Nguyen – Software Engineering Manager (Leads the dev team implementing the app, ensures technical feasibility).
* **IT Security Representative:** Carlos Reyes – Cybersecurity Analyst (Reviews requirements for compliance with NERC CIP and internal security policies; will conduct security testing).
* **Field User Representative:** Bob Lee – Senior Field Technician (Provides user perspective; part of the requirements review/testing group to ensure the app meets field user needs).
* **Regulatory Compliance Officer:** Maria Gomez – Compliance Manager (Advises on regulatory requirements that the app’s data and workflows must adhere to, e.g., reporting, data retention).
* **QA Lead:** Priya Patel – Quality Assurance Lead (Ensures testing covers all requirements and that quality standards are met before release).

Prerequisites:

* Identify all departments and individuals that the product touches. This often comes from a stakeholder analysis in early project planning. If a project charter exists, it may list key stakeholders.
* Confirm with your manager or PMO if there are any stakeholders not immediately obvious (e.g., enterprise architecture group or union representatives if new technology affects union workers).
* Ensure stakeholders are aware of the project and their expected involvement (so listing them in the PRD isn’t a surprise to them).

### Standards and Best Practices

A PRD (or any requirements document) should consider the needs of customers, users, and *other stakeholders*. Stakeholders are typically anyone with a vested interest in the product’s success. Best practice in product management is to involve stakeholders early and document who they are and what role they play. The International Institute of Business Analysis (IIBA) also highlights stakeholder identification as a core step in requirements planning. In this section, keep descriptions concise – the goal is to have a checklist of “who’s who” for consultation and approvals. This aligns with guidance that PRDs outline stakeholder roles and responsibilities so that everyone knows who is involved in what capacity.

## Operating Environment & Technical Constraints

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To outline the environment in which the software will operate and any technical
or regulatory constraints that will impact development. This section informs the
development team of the context and limitations, such as hardware, software, or
policy constraints, ensuring the solution is designed appropriately for its
environment.

Instructions:

* **Operating Environment:** Describe where and how the software will run.
  Include details such as:

  * Target device types (e.g., “iOS tablets provided to field technicians” or
    “Windows 10 laptops in office” or industrial handheld devices) and any
    relevant specifications (memory, ruggedness, etc.).
  * Required operating systems or browser environments (e.g., “Must support iOS
    15 and Android 12; not intended for desktop use”).
  * Network environment: online/offline expectations (e.g., “App must function
    offline for up to X hours and sync when connectivity is restored,” or “Users
    will mainly be on 4G/LTE cellular network with intermittent connectivity”).
  * Integration environment: mention other systems, databases, or services it
    must coexist with or interface to (for example, “coexists with Work
    Management System and GIS database, connecting via REST APIs”).
* **Design & Implementation Constraints:** List any constraints that limit
  developers’ options. These might include:

  * **Corporate/IT Policies:** e.g., mandated use of certain technology stacks
    (perhaps the utility mandates using a particular cloud provider or an
    internal platform), coding standards, or data hosting requirements
    (on-premise vs cloud restrictions).
  * **Regulatory Constraints:** e.g., data retention rules, security standards
    (we must follow NERC CIP cybersecurity requirements, or data residency
    laws), or accessibility requirements (if this app will be used by employees
    with disabilities, must meet ADA/WCAG guidelines).
  * **Hardware Constraints:** e.g., if the field device has limited processing
    power or if certain peripheral devices (like RFID scanners, barcode readers)
    must be supported. Or timing constraints – if it’s used with SCADA systems,
    maybe real-time requirements.
  * **Integration Constraints:** e.g., must use existing company APIs or
    protocols; cannot modify source systems, so any new development must adapt
    to them.
  * **Specific Technologies/Tools:** e.g., “Must be built using .NET and SQL
    Server per IT standard,” or “The mobile app will use the company’s existing
    Mobile Device Management (MDM) framework for deployment.”
  * **Security Constraints:** (overlap with security section) e.g., must use
    single sign-on (SSO) with the corporate Active Directory; encryption
    standards to use; etc.
  * **Other Constraints:** any design conventions (for example, “use the
    corporate UI style guide for consistency with other internal apps”).

Example:

* **Environment:** The Field Service App will run on **rugged iPad tablets
  (iPadOS 16)** that are already used by field crews. The app must also be
  accessible via a web browser (Chrome) for office-based supervisors on Windows
  11 PCs. Field tablets operate mostly on cellular (LTE) networks and
  occasionally lose connectivity in remote areas – the app should store data
  offline and sync when back online. All devices are managed by the company’s
  Mobile Device Management system.
* **Technical Constraints:**
  * *Integration:* The app will integrate with the existing Maximo Work
    Management System via its REST API; we cannot make changes to Maximo itself,
    so we must conform to its API limits (e.g., rate limiting of 100 calls/min).
  * *Technology Stack:* Per IT policy, the backend must use Java/Spring Boot and
    Oracle Database (to align with our enterprise standards), and the mobile
    front-end should be developed in Swift for iOS (since the hardware is iPad).
  * *Security:* Must utilize the company’s Single Sign-On (OAuth2 with Azure
    AD). All data at rest on the device should be encrypted per IT security
    guidelines. There is a constraint that no sensitive data (e.g., customer
    PII) is stored on the device longer than 24 hours (due to security policy).
  * *Regulatory:* The system must follow **NERC CIP standards** for any data
    categorized as critical (e.g., if it stores substation access info) –
    meaning strict access controls and audit logs (see Security & Compliance
    section). Additionally, because this is an internal tool, **Section 508/WCAG
    accessibility** requirements are recommended but not mandated; however, we
    will aim for basic compliance (for any employees with disabilities).
  * *Other:* The solution should “peacefully coexist” with other field apps on
    the tablet – e.g., it should not monopolize device resources. Also,
    development must be done in a way that the **Operations IT team can maintain
    the software** post-launch, so we should avoid obscure frameworks that our
    team isn’t trained in.

Prerequisites:

* Consultation with the **IT infrastructure and architecture teams** to know
  what platforms and tools are approved. This often includes reviewing
  enterprise architecture guidelines or a technical inventory.
* Input from the **field IT support** or end-user computing team about device
  specs and limitations. E.g., confirm what devices field staff have, network
  conditions, and any device management constraints.
* Security policy review to list mandatory security constraints (e.g.,
  encryption, authentication methods) before writing this section.
* If applicable, review of **regulatory standards** (like NERC CIP, OSHA, etc.)
  to capture those constraints accurately.

### Standards and Best Practices

Describing the operating environment is a recommended practice in requirements
docs – it ensures developers understand the context (hardware, OS, other
software) in which the system must operate. Likewise, documenting design and
implementation constraints (corporate policies, hardware limits, required tools,
etc.) is crucial. For example, IEEE SRS guidelines explicitly call out listing
regulatory policies and hardware or technical constraints that limit developers’
options. By capturing these upfront, we align with systems engineering best
practices and avoid rework (e.g., discovering late that our tech choice isn’t
allowed). In an agile setting, some of these constraints might also appear as
“non-functional requirements,” but it’s still useful to consolidate them here
for clarity.


## User Personas

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To describe the end users of the product – their characteristics, needs, and context. Defining user personas ensures the product is built with a clear understanding of who it is for, reflecting user-centric design. In an internal utility context, personas often correspond to job roles (e.g., field technician, system operator, dispatcher) that will use the software.

Instructions:

* Identify the **primary user groups** (personas) of the product. A persona is typically a fictional archetype that represents a group of users with similar goals and behaviors. For each persona:

  * **Name or Role:** Give the persona a descriptive name (e.g., “Frank – Field Technician”) and/or simply use the role title (Field Technician, Field Supervisor, etc.).
  * **Profile:** Describe relevant characteristics: their job responsibilities, skill level, background, technical expertise, frequency of using the software, environment of use, and any pain points or needs. Include details like: Are they tech-savvy or not? Working conditions (e.g., in the field under harsh weather, in an office)? What are their main goals when using this product?
  * **Needs and Frustrations:** Summarize what this persona needs from the product and any current frustrations with existing tools or processes. This ties the product features to user value.
* Typically, highlight 2-4 personas: e.g., a primary end-user persona, perhaps a secondary persona like a manager or administrator, etc. Distinguish the *most important* persona (the one who must be satisfied) versus others.
* You can present personas as a short paragraph or bullet profile for each. Optionally include a made-up quote or scenario illustrating their perspective (“I spend too much time filling forms…”).
* Include any **accessibility or special considerations** if relevant (e.g., if some users have limited connectivity or low computer literacy, etc.). This will guide UX decisions later.

Example:

* **Field Technician (Primary Persona):** Typically aged 30-55, skilled in electrical equipment maintenance but **not extremely tech-savvy**. Works outdoors on power lines and substations, often in remote areas with spotty internet. Uses the application daily to receive work orders and report completion. *Needs:* a very straightforward, quick app with offline capability and minimal typing (since they might be wearing gloves or in bright sunlight). *Frustrations:* current paper process means duplicate data entry at day’s end, and loss of paperwork is common. This persona values speed and reliability; they care about not having to redo work due to app issues.
* **Field Supervisor (Secondary Persona):** Oversees a team of field techs. More office-based but occasionally in the field. Uses the system to assign tasks and monitor status. Technically proficient with basic software. *Needs:* real-time visibility of crew progress, ability to reassign work quickly if someone is delayed. *Frustrations:* lacks timely data today, often has to call technicians for updates. This persona desires better reporting and fewer surprise delays.
* **IT Support/Admin (Secondary Persona):** Manages user accounts and ensures the app is functioning. Not a direct business user of the app’s main features, but needs administrative interfaces to manage configurations, permissions, etc. *Needs:* easy user management, error logs to troubleshoot issues. *Frustrations:* current legacy system is hard to maintain. (This persona ensures the solution is maintainable and secure.)

Prerequisites:

* Conduct user research or at least interviews/job shadowing with people in those roles. If formal research isn’t done, involve subject matter experts (e.g., a veteran field technician) to validate persona details.
* Understand the **user environment**: e.g., field conditions, devices they use (tablet, phone, laptop), any safety or environmental conditions (like needing gloves, or hazard zones where phone use is limited).
* Compile any existing user profiles or training documents that describe these roles (utilities often have training personas or ergonomic studies for field roles that can be referenced).

### Standards and Best Practices

Understanding user classes and characteristics is crucial in requirements engineering. You should differentiate personas based on factors like frequency of use, technical expertise, and access level. For instance, an internal standard might require considering users with different privilege levels (regular tech vs. supervisor). Many product frameworks (like user-centered design and Agile) encourage using personas to keep development focused on user needs. In Agile/XP, the concept of the “user” is central to user stories (“As a *field technician*, I want…”) – having well-defined personas makes those stories more precise. While there’s no ISO standard for personas, the practice aligns with ISO 9241 (Ergonomics of human-system interaction) guidance to consider user characteristics in design. Make sure personas are believable and based on real observations to effectively guide product decisions.

## User Scenarios & Use Cases

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To illustrate how users will interact with the product through real-world scenarios. User scenarios (or use cases) provide narrative examples of the product in action, demonstrating how it fulfills user needs. This helps everyone visualize functionality in context and ensures the requirements cover all intended user flows. It serves as a bridge between high-level objectives and detailed requirements.  The purpose of defining acceptance criteria is to establish clear, specific, and testable conditions that verify the successful implementation of user scenarios. Acceptance criteria ensure alignment between stakeholders, developers, and QA teams by articulating the initial context, user actions, and expected outcomes. These criteria serve as the foundation for User Acceptance Testing (UAT), providing a measurable standard to confirm that the product meets user requirements and expectations. In Agile workflows, acceptance criteria represent the confirmation of a user story’s completion and act as a shared agreement on what constitutes "done."

Instructions:

* Write **user scenarios or use cases** that describe typical end-to-end activities a user (or multiple users) would perform using the product. These can be formatted as short paragraphs or step-by-step narratives. Focus on the *goal* the user is trying to accomplish and how the product enables it.
* Ensure scenarios cover the primary personas and their main goals. For each scenario, identify the persona involved and the context. Example format: “*As a \[persona], when \[situation], I \[do something in the product] to achieve \[goal].*” This can be a narrative instead of the strict user story one-liner.
* Include a few main scenarios: e.g., “Field Technician completes a work order in the field,” “Field Supervisor assigns work and monitors progress,” etc. You might also include edge cases or failure scenarios if important (e.g., “Technician works offline due to no signal and later syncs data”).
* Each scenario should cover: **Trigger/Context** (what prompts the user to use the product), **Steps/Interaction** (how they use the product, key actions), and **Outcome** (what they accomplish or what the system provides).
* *If using formal use case format:* you can list “Actors, Precondition, Main Flow, Alternate Flow, Postcondition” etc., but for an Agile/XP context, a simple narrative is usually sufficient.
* After writing each scenario, list the Acceptance Criteria for it – these are the conditions that must be met for the scenario to be considered successfully implemented. Write acceptance criteria as testable statements, often using the format Given-When-Then (Behavior-Driven Development style) to specify conditions, user actions, and expected outcomes . This ensures each scenario is clearly measurable and can be validated through testing. For example: Given a field technician is offline, when they complete a work order, then the data is queued and later synced once connectivity is restored.

Example:

*(User Scenarios)*

* **Scenario 1: Completing a Work Order (Field Technician):** *Frank, a field technician, starts his day by opening the Field Service App on his tablet. He sees a list of assigned work orders for the day, one of which is a transformer maintenance task. He selects the task to view details (location, priority, safety notes). After driving to the site, Frank uses the app to check off each maintenance step as he performs it, captures a photo of the replaced part, and adds a comment. Mid-way, he loses cell signal – the app notifies him it’s offline but continues to let him enter data. Once the job is done, Frank marks the work order as completed. Later, when back in coverage, the app automatically syncs his updates to the central system. Frank receives confirmation that the data was uploaded successfully.* (Outcome: The work order is recorded in real-time with evidence, and Frank avoids paperwork.)
  * **Acceptance Criteria**
  * **Given** Frank has a pending work order assigned in the Field Service App, when he opens the app and selects the work order, then the system displays all relevant details of the job (including location, priority, and notes).
  * **Given** the field technician completes each maintenance step and adds notes/photos, when Frank marks a step as done or uploads a photo (with network available), then the app saves the update in real-time and associates it with the work order record.
  * **Given** the technician is in an area with no cell signal, when the app switches to offline mode during a work order, then Frank can continue to check off steps, enter comments, and capture photos without error, and the data is stored locally for later sync.
  * **Given** Frank completed the work order while offline, when connectivity is restored (or Frank manually triggers “Sync Now”), then the system automatically uploads all queued updates and marks the work order as completed in the central system, and Frank receives a confirmation that the data synced successfully.

* **Scenario 2: Assigning and Monitoring Work (Field Supervisor):** *Maria, a maintenance supervisor, logs into the web dashboard in the morning. She reviews all open work orders. Through the interface, she assigns a high-priority repair job to the nearest available technician (the system suggests Frank based on location). As the day progresses, Maria checks the live status on the dashboard; she sees Frank’s task marked completed and opens it to review the attached photo and notes. Pleased with the quick turnaround, she generates a report of completed orders for the day to send to management.* (Outcome: The supervisor efficiently distributes work and monitors field activity without phone calls.)
  * **Acceptance Criteria**
  * **Given** there are one or more open work orders in the system, when Maria (Field Supervisor) logs into the dashboard, then she can view a list of all open work orders with key details (e.g. locations, priorities, statuses).
  * **Given** a high-priority repair job is unassigned and technicians have location data, when Maria assigns the job through the interface, then the system recommends an appropriate technician (e.g. nearest available) and allows Maria to confirm the assignment, updating the work order’s status to “Assigned” with the technician’s name.
  * **Given** Maria has assigned a work order to a technician, when that technician (Frank) marks the work as completed in the field, then Maria’s web dashboard updates the task status to “Completed” in real-time and she can open the work order to review details (including any attached photos and notes).
  * **Given** a day’s field work has concluded, when Maria requests or generates a report of completed orders for that day, then the system produces a report listing all completed work orders and their key details (technician, completion time, notes) which Maria can download or forward to management.

* **Scenario 3: Offline Data Sync (Edge Case):** *While working underground, Frank cannot upload data. The scenario of offline mode kicks in: the app queues Frank’s updates. Frank finishes 3 jobs while offline. Once he returns to an area with coverage, he opens the app and sees a notification “3 work orders pending upload.” He taps “Sync Now,” and the data transmits. The central system is updated, and Maria’s dashboard now reflects those jobs as completed.* (Outcome: Offline work is gracefully handled, preventing data loss.)
  * **Acceptance Criteria**
  * **Given** the field technician is performing work orders in an area with no network connectivity, when the app is offline, then all of the technician’s inputs (completed tasks, notes, photos for each job) are queued/stored safely on the device and an indicator shows pending uploads (e.g. “3 work orders pending upload”).
  * **Given** there are pending work order updates waiting to sync, when the device later connects to a network (or the technician manually initiates a sync), then the app successfully uploads all queued work order data to the central system and updates each work order’s status to completed.
  * **Given** the offline updates have been synced, when the sync is finished, then the technician receives a confirmation (e.g. a notification or status message that all data is synced), and the supervisor’s dashboard reflects those work orders as completed (just as if they had been updated in real-time).

Prerequisites:

* Knowledge of the **users’ workflows** and daily routines to craft realistic scenarios. This often comes from process documentation or user interviews.
* Understanding of the **product features** that will support these scenarios (so that you don’t describe something the product won’t do). Early design thinking or requirements brainstorming helps shape these scenarios.
* Possibly a prior **“journey mapping”** exercise – sometimes teams map out a user’s journey through a task with pain points, then design the new solution. Those journey maps can feed into these scenarios.
* Familiarity with writing acceptance criteria for user stories, to ensure you can translate each scenario into testable conditions. This may involve collaboration with QA to understand how each scenario will be tested.

### Standards and Best Practices

User scenarios (or use cases) are a common way to ensure requirements are rooted in real user needs. Atlassian’s and Product School’s templates suggest including full **user stories or scenarios** about how personas will use the product in context. This narrative approach aligns with agile and user-centered design principles by keeping the focus on user goals. In more formal terms, it resembles use case modeling (UML use cases) where you describe interactions between an “actor” (user) and the system to achieve a goal. IEEE SRS standards often include use cases in an appendix or prior to functional requirements to illustrate requirements in context. Including scenarios here helps validate that the functional requirements (next section) adequately support all critical user flows. It’s also a communication tool – stakeholders can read a scenario and confirm “Yes, this is how we expect it to work.”

Additionally, it’s a best practice to include acceptance criteria with each scenario or user story. This ensures there is a clear definition of done for each feature. The acceptance criteria should be unambiguous and testable, so that during UAT and QA testing, everyone can agree whether each condition is met. By writing them in a Given/When/Then format (or as a checklist of verifiable statements), you make it easier to develop test cases and avoid misunderstandings about expected behavior  . Ultimately, well-defined acceptance criteria improve quality and serve as a contract that the development team, product owner, and QA all understand and sign off on.


## Functional Requirements & Features

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To enumerate the specific functional capabilities that the product must provide. This section breaks down the product into individual features or requirements, describing what the system should do to support the user needs and scenarios described earlier. It forms the core checklist for developers to implement and testers to verify.

Instructions:

* List the **functional requirements** of the product. There are two common ways to do this, and you can choose based on your methodology (or even combine them):

  * **User Story format (Agile/XP):** Write requirements as user stories, e.g., “As a *\[user persona]*, I want *\[some capability]*, so that *\[benefit]*.” Each user story represents a feature or piece of functionality. Include acceptance criteria for each story if possible, to clarify when the story is “done.” (e.g., “Given I am logged in, when I submit a work order form offline, then it is saved locally and synced later.”)
  * **System Requirement format (Traditional/Waterfall):** Write statements of what the system accomplishes, these requirements follow this format: "The [System that this requirement is assigned to] [Shall {for requirements} | Will {for facts or declaration of purpose} | Should = {for goals}] [Do some capability or create some business outcome] while [some set of conditions need to be met that can be measured] [under some measurable constraint]. These should be clear, atomic requirements. They might be organized under feature headings (e.g., “Work Order Management” as a sub-section with multiple requirements). Each requirement can be tagged/numbered (e.g., REQ-1, REQ-2) for traceability.
  * **Acceptance Criteria:**  Write Acceptance Criteria for each requirement using Gherkin Scripts taken from Behavior-Driven Development, e.g., "*\[Scenario: A labor for the behavior being described]*: Given *\[The Starting Condition for the scenario to test, include any preconditions, environmental details, or relevant information]*, When *\[A specific action that the user takes or an automated process takes within the system takes]*. Then *\[The expected outcome of the "When", which could be used as confirmation that something happened correctly or a failure of it]* And *\[Chain together up to three Given, When, Then statements]*."
* Ensure that each requirement is **clear, testable, and necessary**. Avoid ambiguity. For instance, instead of “system should be user-friendly” (which is vague), specify “system shall allow a technician to complete the work order form in 5 minutes or less” or capture “user-friendly” aspects under UX requirements.
* It can be helpful to group requirements by feature area or module (matching perhaps the “Epics” or major features). For example: “Login & User Management,” “Work Order Processing,” “Mapping/GIS Features,” “Reporting,” etc., each with specific requirements.
* If priority or release phase is relevant, mark each requirement with a priority (High/Must-have, Medium/Nice-to-have, Low/Future) that link to the MoSCoW categories. In Agile, you might implicitly do this via backlog ordering, but in a PRD it’s often helpful to indicate critical vs optional features.
* Use bullet points or a numbered list for readability. Keep each requirement concise (one feature per statement). If additional explanation is needed for a requirement, you can indent a sub-bullet or add a brief rationale.
* Verify that every functional requirement traces back to a user need or objective (use the earlier sections to ensure coverage).

Example:

* **Work Order Management:**

1. [Scenario: Viewing Assigned Work Orders] - “As a Field Technician, I want to view a list of my assigned work orders for the day, so that I can plan and prioritize my tasks.”

* **Given** the Field Technician logs into the mobile application at the start of the day and has at least one work order assigned,
  * When the technician navigates to the “Today’s Work Orders” section,
  * Then the system shall display a list of work orders showing order ID, location, priority, and due date.
  * And the list shall be sorted first by priority (descending), then by due time (ascending).

2. [Scenario: Updating Work Orders While Offline] - "The system shall allow the Field Technician to update a work order’s status and record task results while offline."

* **Given** the Field Technician is working in an offline environment and opens a previously downloaded work order,
  **When**  they update the status of the work order to “Started,” add notes, and attach photos,
  **Then** the system shall allow all changes and store them locally on the device.
* **Given** a network connection is later established,
  **When**  the application detects connectivity or the technician taps “Sync Now,”
  **Then** the stored data shall be uploaded to the central server and reflected in the supervisor’s dashboard in real time.

3. [Scenario: Notifying Supervisor on High-Priority Completion] - "The system shall send a notification to the supervisor when a high-priority work order is completed."

* **Given** a Field Technician completes a work order that is marked as high priority and updates its status to “Completed,”
  **When**  the application syncs this change to the server,
  **Then** a push notification or alert message shall be sent to the assigned Supervisor’s device or dashboard immediately.
  **And** the notification shall include the work order ID, location, and technician name.

4. [Scenario: Viewing Work Orders on a Map] - “As a Field Technician, I want to see the location of my work orders on a map, so that I can navigate to the site efficiently.”

* **Given** the technician opens the “Map View” screen within the app while online,
  **When**  the system loads the map tiles for the current and upcoming work order locations,
  **Then** pin markers shall be displayed for each assigned work order with basic details accessible upon tap.
* **Given** the technician loses internet connection,
  **When**  they reopen the app in an offline area,
  **Then** the previously loaded map and work order markers shall remain visible and functional,
  **And** tapping a marker shall still show work order info and provide an option to open the location in an external navigation app.

5. [Scenario: Logging in with Corporate SSO] - "The system shall integrate with the corporate Single Sign-On (SSO)."

* **Given** the user opens the mobile or web app and is not logged in,
  **When**  they click “Sign in,”
  **Then** the system shall redirect to the corporate SSO login screen and accept valid company credentials.
* **Given** the credentials are valid,
  **When**  the user successfully authenticates,
  **Then** the system shall create a session and route the user to their appropriate dashboard.
  **And** no separate app-specific password shall be required.

6. [Scenario: Enforcing Role-Based Access Control] - The system shall enforce role-based access control.

* **Given** a user logs into the system,
  **When**  their role is identified as Technician,
  **Then** they shall only be able to view and update work orders assigned to them.
* **Given** a Supervisor logs in,
  **When**  they access the work order list,
  **Then** they shall be able to view and reassign work orders within their region.
* **Given** an Admin user logs in,
  **When**  they navigate to the user management or audit section,
  **Then** they shall be able to view all user accounts, roles, and audit logs across all regions.

7. [Scenario: Downloading a Daily Summary Report] - “As a Field Supervisor, I want to download a daily summary report of completed and pending work orders, so that I can report progress to management.”

* **Given** the Supervisor logs into the web dashboard before 5 PM,
  **When**  they navigate to the “Daily Reports” section and select “Download,”
  **Then** the system shall generate a report (PDF or Excel) including all completed and pending work orders as of that day.
  **And** the report shall include metadata such as task IDs, completion timestamps, technician names, and any overdue items.

Prerequisites:

* You should have completed the **user scenarios** and have a good understanding of what functions are needed. Ideally, you’ve also consulted subject matter experts or users to validate these functions.
* If following Agile, a **product backlog** or list of user stories might already exist from discovery workshops – those can be refined and included here. If following a traditional approach, a business requirements document or use case documents might have been created, which you now translate into functional requirements.
* The team should align on a **level of detail** for requirements. Sometimes early PRDs keep it higher-level (epics/features), especially in agile contexts, deferring detailed user stories to the backlog. Make sure this section’s granularity matches how the team will implement (e.g., each bullet could correspond to a backlog item or development task).
* Acceptance Criteria should be completed as the stories and the requirements are finalized.  If the stories and requirements are not finalized, then the Acceptance Criteria needs to be updated every time the associated need is changed.
* Before Acceptance Criteria is finalized, there needs to be an agreement with the customer and business process owner where the testing will take place (Test Environment) and which datasets will be used.

### Standards and Best Practices

Functional requirements should be *clear, unambiguous, and verifiable*. According to IEEE standards, each requirement should be concise, complete, and testable. In a Waterfall model, you might enumerate “The system shall…” statements with unique identifiers. In Agile, writing user stories is common; when doing so, follow the **INVEST criteria** – each story should be Independent, Negotiable, Valuable, Estimable, Small, and Testable. For example, ensure every user story clearly states the value (so that it’s truly needed) and is small enough to implement in a short iteration. It’s also advisable to avoid prescribing the solution in this section – focus on *what* the system should do, not *how* to do it (leave design decisions for later), unless a particular implementation is a constraint. By adhering to these guidelines, the requirements become actionable for development and measurable for QA.  INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile Definition‑of‑Done checklists.

## UI / UX Design Specifications

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Describe how the product should look and feel so that developers and designers
deliver a consistent, user‑friendly experience aligned with corporate style and
field‑use constraints.

Instructions:

1. Design Principles – List the key principles to follow (e.g., “mobile first,”
  “glove‑friendly controls,” “minimal data entry”).
2. Visual Standards – Reference corporate style‑guide elements: color palette,
  typography, spacing, iconography.
3. Interaction Patterns – Define reusable UI patterns (e.g., bottom‑navigation
  bar, modal confirmation dialogs, offline status banner).
4. Accessibility – Specify WCAG 2.1 AA criteria the app must meet (contrast
  ratios, alternative text, focus order, etc.).
5. Artifacts – Link to wireframes, high‑fidelity mock‑ups, interactive
  prototypes, and a component library (e.g., Figma file).
6. Usability KPIs – List measurable UX targets (task completion time, error
  rate, SUS score).

Example:

* Design Principle: “Field‑Friendly.” All actionable controls ≥ 44 × 44 px;
  primary buttons left‑aligned for one‑handed thumb use.
* Visual Standards: Use Blue Fire #00A9E0 for primary actions; body text 16 pt
  San Francisco; icons from the internal Ion Icon set.
* Interaction Patterns: Swipe‑to‑complete pattern for quickly closing a work
  order.
* Accessibility: All static text passes 4.5:1 contrast; voice‑over labels
  present on every icon.
* Artifacts: See Figma → Field App v2 → Frames 1‑20 for annotated mock‑ups.
* Usability KPIs - These Key Performance Indicators (KPIs) measure how usable
  and efficient the Field Service Mobile App is for real-world use by utility
  field technicians and supervisors.
  * **SUS**, **error rates**, and **first-time success** should be measured via
    pilot studies or usability tests.
  * **Tap accuracy**, **task time**, and **navigation steps** can be tracked via
    usage analytics or observed in test labs.
  * KPIs should be reviewed after initial deployment and used to inform
    iterative UX improvements.

| **KPI Name**                           | **Target**                                                                          | **Rationale**                                                                     |
|----------------------------------------|-------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------|
| **Task Completion Rate**               | ≥ 95% of users can complete core tasks (e.g., update work order) without assistance | Confirms the system is intuitive and meets baseline usability expectations.       |
| **First-Time Task Success**            | ≥ 90% of new users complete a task without training                                 | Measures learnability for new or infrequent users; critical for field deployment. |
| **Time to Complete Work Order**        | Median time < 3 minutes                                                             | Ensures workflows are efficient and do not slow down field operations.            |
| **Error Rate per Task**                | < 2% user-generated errors (e.g., failed submissions)                               | Indicates clarity of design and resilience to user mistakes.                      |
| **System Usability Scale (SUS) Score** | ≥ 75 (from technician surveys post-deployment)                                      | Benchmarks user satisfaction against industry standards.                          |
| **Tap Accuracy Rate**                  | ≥ 98% for key UI controls (buttons, lists, inputs)                                  | Ensures UI is accessible with gloves and in adverse field conditions.             |
| **Offline Sync Success Rate**          | ≥ 99% of queued tasks sync successfully after reconnecting                          | Validates offline mode robustness for areas with poor or no connectivity.         |
| **Training Time for New Users**        | ≤ 1 hour to reach basic proficiency                                                 | Ensures the app is simple enough for rapid onboarding and minimal friction.       |
| **Navigation Steps per Task**          | ≤ 3 taps to complete a primary task                                                 | Minimizes cognitive load and streamlines daily work for field crews.              |
| **Help/Support Usage Rate**            | ≤ 10% of users need in-app help or raise support tickets                            | Low support needs suggest intuitive design and clear workflows.                   |

Prerequisites:

* Finalized corporate style guide and component library access.
* UX research insights/persona pain points.
* Device usage constraints (sunlight readability, glove use, etc.).

Standards & Best Practices:

WCAG 2.1, ISO 9241‐210 (Human‑centred design), Nielsen 10 usability heuristics,
Apple HIG / Material Guidelines (for native iOS/Android patterns).

## Data Management & Governance

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Define how data is created, owned, classified, governed, audited, and
lifecycle-managed within the product. This section establishes authoritative
sources, accountability, lineage, and auditability for all data handled by the
system, ensuring regulatory compliance, operational integrity, and long-term
maintainability in a utility environment.

Instructions:

1. **Identify core data entities**

  * Enumerate all primary and secondary data entities the product creates,
    reads, updates, or stores (e.g., work orders, assets, inspections, photos,
    notes, telemetry).
  * Include derived and transient data where operationally significant.

2. **Define system of record (SoR)**

  * For each data entity:

    * Identify the authoritative system of record.
    * State whether this product is:

      * The system of record
      * A system of entry
      * A system of reference/replica
  * Explicitly prohibit ambiguous ownership.

3. **Assign data ownership and stewardship**

  * For each data entity:

    * Identify the **Business Data Owner** (accountable for correctness and
      use).
    * Identify the **Data Steward** (responsible for quality, definitions, and
      access).
    * Identify the **Technical Custodian** (responsible for storage and
      pipelines).

4. **Classify data**

  * Classify each data entity according to enterprise data classification
    policy.
  * Explicitly flag:

    * PII / SPI
    * CIP-sensitive or operationally sensitive data
    * Safety-critical data
  * Define handling requirements by classification.

5. **Define data lineage**

  * For each data entity:

    * Identify source system(s).
    * Describe transformations, enrichments, or aggregations.
    * Identify downstream consumers (systems, reports, regulatory outputs).
  * Capture lineage at a logical level (not implementation detail).

6. **Define synchronization and conflict resolution rules**

  * For data that may be edited or created in multiple systems:

    * Define authoritative write rules.
    * Define conflict detection triggers.
    * Define conflict resolution policy (automatic, manual, precedence-based).
  * State rules as **product behavior**, not technical patterns.

7. **Define retention, logging, and audit artifacts**

  * For each data entity:

    * Define retention duration.
    * Define archival vs deletion rules.
  * Define audit artifacts that must be producible:

    * What evidence
    * In what format
    * Within what time window

8. **Define data access and usage constraints**

  * Define role-based access expectations.
  * Define permitted vs prohibited secondary uses of data.
  * Identify data-sharing constraints with external systems.

Example:

**Core Data Entities**

| Data Entity      | System of Record                  | Business Owner           | Data Steward            | Classification          |
| ---------------- | --------------------------------- | ------------------------ | ----------------------- | ----------------------- |
| Work Order       | Work Management System (WMS)      | Director, Operations     | Operations Data Steward | Operationally Sensitive |
| Asset            | Enterprise Asset Management (EAM) | Director, Asset Strategy | Asset Data Steward      | CIP-Sensitive           |
| Inspection Photo | This Product                      | Director, Field Ops      | Field Data Steward      | PII / Operational       |
| Technician Notes | This Product                      | Director, Field Ops      | Field Data Steward      | PII                     |

**System of Record Rules**

* This product is **not** the system of record for Work Orders or Assets.
* This product **is** the system of record for Inspection Photos and Notes.
* Updates to Work Order status must be written back to WMS within 5 minutes or
  queued for retry.

**Data Lineage**

* Work Order:

  * Source: WMS
  * Enrichment: Location metadata from GIS
  * Consumers: Reporting Warehouse, Regulatory Audit Reports
* Inspection Photos:

  * Source: Mobile Client
  * Transformation: Compression, metadata tagging
  * Consumers: Safety Review, Claims Investigation

**Synchronization & Conflict Resolution**

* Offline edits allowed for Inspection Notes.
* Conflict detected when server version updated after client sync timestamp.
* Resolution policy:

  * Server version retained as authoritative.
  * Client version stored as supplemental record.
  * Supervisor review required for merge.

**Audit Artifacts**

* Ability to produce:

  * Full work order change history
  * Timestamped photo metadata (who, where, when)
  * Access logs for CIP-sensitive data
* Evidence must be producible within 5 business days of request.

**Retention**

* Inspection Photos: 7 years
* Notes: 7 years
* Sync logs: 90 days
* Access logs: 1 year

Prerequisites:

* Functional requirements defined.
* Non-functional and security requirements identified.
* Enterprise data classification policy available.
* Stakeholders and data owners identified.
* Upstream and downstream systems known.

### Standards and Best Practices

* DAMA-DMBOK (Data Governance and Stewardship)
* ISO/IEC 27001 (Information Security Management)
* NIST SP 800-53 (Data protection and auditing controls)
* NERC CIP (for electric utilities)
* GDPR / CCPA (for PII handling, where applicable)
* ITIL 4 – Information Management
* Utility best practice: always name a system of record per entity
* Treat sync conflict rules as product policy, not technical implementation
* Design audit evidence first, not after an incident
* Prefer lineage clarity over technical completeness

## Security & Compliance Requirements

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To detail the specific security measures and compliance obligations the product must adhere to. This section is crucial for a utility company, as such companies operate critical infrastructure and are subject to strict regulations (e.g., cybersecurity standards, data privacy laws, safety regulations). It ensures that security is built into the product from the start and that the product will not violate any legal or regulatory requirements.

Instructions:

* **Security Requirements:** List the security controls and features that the product must implement. This can include:

  * **Authentication & Authorization:** e.g., “Must integrate with Single Sign-On (SSO) using company credentials” (as noted in functional req, but reiterate here if needed), “Users are assigned roles with least privilege access (technicians cannot access admin features, etc.).”
  * **Encryption:** “All data in transit must be encrypted (TLS), and sensitive data at rest encrypted (AES-256, etc.).”
  * **Data Protection:** e.g., “The mobile app shall store data in an encrypted format on-device and wipe cached data after X days.”
  * **Logging & Auditing:** “System must log user actions like login, data changes, and have audit logs that can be reviewed. Logs should include user ID, timestamp, action, and be tamper-evident.”
  * **Security Testing & Compliance Checks:** e.g., “The product must pass a penetration test by the internal security team before go-live” or “Must comply with OWASP Top 10; no critical or high vulnerabilities in final security scan.”
* **Regulatory Compliance:** List any external regulations or standards the product must comply with, and specific requirements to meet them. Examples relevant to a California utility IT product:

  * **NERC CIP (Critical Infrastructure Protection standards):** If the system is part of bulk electric system operations or contains critical cyber assets. Requirements might include strong access controls, background checks for admins (maybe not directly in software but process), specific logging and incident response features. *For example:* “The system must comply with NERC CIP standards for cybersecurity, including role-based access control, annual cyber vulnerability assessments, and strict change management logging for any software modifications.”
  * **California Consumer Privacy Act (CCPA):** If the product deals with personal data (even employee personal data or customer data), ensure compliance with data handling rules. e.g., “If any personal identifiable information (PII) is stored (like customer contact within a work order), the system must allow for data removal and disclosure reporting per CCPA requirements.”
  * **California/OSHA Safety Regulations:** If the software usage intersects with safety (like field use in hazardous areas), ensure compliance with any safety policies. E.g., “The app will include a safety acknowledgment for switching operations, as required by OSHA and company policy.”
  * **Records Retention Laws:** Utilities often must retain certain records. If this app’s data is subject to CPUC or FERC record retention rules, state those (which might overlap with NFR data retention in previous section).
  * **Internal Compliance:** e.g., internal IT compliance standards, like “Must comply with Company XYZ’s Software Development Lifecycle requirements, including code review and change management processes as audited by internal compliance.”
* **Industry Standards:** Mention any other relevant standards: e.g., “Encryption must follow NIST guidelines (FIPS 140-2 compliant cryptographic modules)” or “The system should comply with IEC 62351 (security for IEC 61850 systems) if relevant to substation communications” – only if applicable.
* Each requirement should be clear and testable. Some compliance requirements may require documentation rather than features (e.g., proving via audit that you meet them). Still, list what the system needs to provide or allow to ensure compliance.

Example:

* **Authentication & Access Control:** The application shall utilize **Azure Active Directory SSO** for user login. Technicians and supervisors authenticate with their corporate credentials and a second factor (MFA). The system will enforce role-based access as defined (Tech, Supervisor, Admin roles with predefined permissions). Account provisioning and de-provisioning will be handled via the corporate directory to ensure only current employees have access.
* **Given** a user (Technician, Supervisor, or Admin) launches the app,
  **When** they initiate login,
  **Then** they shall be redirected to the corporate **Azure Active Directory SSO** login page and prompted for their corporate credentials.
* **Given** the user enters valid credentials,
  **When** the system requests the second authentication factor,
  **Then** the user shall be authenticated via **MFA**, and upon success, be granted access to the system.
* **Given** the user’s role is known,
  **When** the login completes,
  **Then** the system shall enforce **role-based access controls**, restricting visible features and actions to those associated with their assigned role.
  **And** the account must be automatically provisioned or de-provisioned based on **Active Directory membership status**.
* **Audit Logging:** All critical actions (e.g., completing a work order, changing a work order assignment, admin changes to user roles) must be **logged with user ID, timestamp, and details**. Logs should be immutable (or properly secured against tampering) and exported to the central SIEM (Security Information and Event Management) system daily for monitoring.
  * **Given** a user completes a critical action (e.g., marking a work order complete, reassigning work, or changing user permissions),
    **When** the action is committed,
    **Then** the system shall create a **log entry** capturing the **user ID, timestamp, action type, and affected entity**.
  * **Given** logs are collected continuously throughout the day,
    **When** the scheduled export job runs daily,
    **Then** the logs shall be securely transmitted to the **central SIEM system** for monitoring and alerting.
    **And** the logs must be **immutable** (or write-once protected) to prevent tampering.
* **Data Encryption:** Data in transit between the mobile app and server will use HTTPS with TLS 1.2+. For data at rest, the server database will use encryption (TDE – Transparent Data Encryption). On the mobile device, local data caching will be encrypted using the device’s secure storage mechanism.
  * **Given** a technician’s mobile device connects to the server to transmit data,
    **When** the data exchange begins,
    **Then** the connection shall be secured using **HTTPS over TLS 1.2+** to encrypt data in transit.
  * **Given** data is stored on the backend database,
    **When** it is written to disk,
    **Then** the database shall employ **Transparent Data Encryption (TDE)** to protect the data at rest.
  * **Given** the mobile device caches any work order data locally,
    **When** that data is stored for offline access,
    **Then** it must be encrypted using the device’s **native secure storage mechanisms** (e.g., Android Keystore or iOS Keychain).
* **NERC CIP Compliance:** Although this application is not directly controlling the grid, if it stores or transmits any Bulk Electric System (BES) Cyber System information, it must adhere to **NERC CIP requirements**. Specifically:
  > * Unique user IDs for each person (no shared accounts) and MFA (meets CIP-005 remote access requirements).
  > * Audit logs as described align with CIP-007 logging requirements.
  > * If classified as a low-impact BES Cyber System, ensure an incident response plan exists (though this is procedural, the app should facilitate incident response by providing necessary logs).
  > * The development team will consult with the compliance team to ensure all relevant CIP controls (CIP-002 through CIP-011 series) are considered, even if the system likely falls outside high/medium BES classification.
  * **Given** the application may store or transmit data related to Bulk Electric System assets,
    **When** a user account is created,
    **Then** the system shall assign a **unique user ID** and disallow shared accounts, in accordance with **CIP-005**.
  * **Given** the user logs in remotely,
    **When** authentication is requested,
    **Then** **MFA** shall be enforced to meet **CIP-005 remote access standards**.
  * **Given** an action is performed within the system,
    **When** it qualifies as critical (e.g., work order completion, admin action),
    **Then** an **audit log entry** shall be generated in accordance with **CIP-007**.
  * **Given** a security event occurs,
    **When** the compliance team initiates an investigation,
    **Then** the system shall provide **sufficient logging** to support an incident response aligned with **CIP-008 and CIP-009** procedures.
* **Privacy (CCPA):** The system will store employee IDs and possibly names (for assignment, etc.). This is considered personal data. We must allow administrators to delete or anonymize personal data if an employee leaves, and protect it from unauthorized access. Any use of customer data (if any in future) will trigger full CCPA compliance including the ability to provide data copies and deletion upon request.
  * **Given** employee personal data (e.g., ID, name) is stored in the system,
    **When** an employee leaves the company,
    **Then** an **administrator shall be able to delete or anonymize** the personal data, and confirm removal through audit logs.
  * **Given** a data subject (employee or customer) requests a copy of their stored personal data,
    **When** an admin executes the export function,
    **Then** the system shall provide a complete **data export in a human-readable format** within the required timeframe.
  * **Given** data is no longer required for business or regulatory reasons,
    **When** a deletion request is valid,
    **Then** the system must purge the data securely,
    **And** prevent future unauthorized access.
* **Internal IT Compliance:** The project will undergo **Security Review and Approval** by the IT Security team prior to launch. All open security findings must be remediated or explicitly acknowledged by risk owners. Additionally, the app must comply with our **Software Quality Policy** – meaning it will not go live with any open Severity 1 or 2 defects, and must pass User Acceptance Testing including security test cases.
  * **Given** the app is ready for production deployment,
    **When** the Security Review is conducted by the corporate IT Security team,
    **Then** all **critical vulnerabilities (Severity 1 or 2)** must be **remediated or explicitly accepted by the designated risk owner**.
  * **Given** UAT is scheduled,
    **When** security-related test cases are executed,
    **Then** the system must pass **100% of UAT security validation tests** prior to go-live.
  * **Given** any Severity 1 or 2 defects are still open,
    **When** the release candidate is reviewed,
    **Then** deployment shall be **blocked until those defects are resolved or waived** with documented risk acceptance.
* **Physical Security & Safety:** The application will display a warning reminder when opened in a vehicle (to remind technicians not to use the app while driving) – aligning with our company’s safety policies for driving. This isn’t a regulatory mandate but a compliance with internal safety rules to reduce distracted driving incidents.
  * **Given** a field technician opens the mobile app while inside a moving vehicle,
    **When** the application is launched,
    **Then** a **safety warning message** shall be displayed reminding the user not to interact with the app while driving.
  * **Given** the technician dismisses the warning,
    **When** the app resumes functionality,
    **Then** no critical input features (e.g., submitting work order data) shall be automatically activated,
    **And** the app must not encourage interaction while the vehicle is in motion, in compliance with internal safety policy.

Prerequisites:

* Involvement of the **cybersecurity team** to identify relevant security requirements and any regulatory triggers (like NERC CIP applicability). Possibly perform a threat model or security risk assessment for the product to decide on controls.
* Reference to **compliance documents**: e.g., NERC CIP standards documentation, internal compliance checklists, California privacy laws summary. Ensure you have the latest requirements from those sources.
* Coordination with the **legal/regulatory department** if necessary, to confirm which laws/regulations impact this software (for instance, confirming whether CCPA applies to employee data, etc.).
* Corporate **IT policies** for security (most IT departments have standard requirements for new applications – like password policies, data encryption standards, etc., which should be integrated here).

### Standards and Best Practices

Utility companies are heavily regulated and are expected to build systems with compliance in mind. For instance, NERC CIP is a mandatory cybersecurity standard for power utilities – even if this system is not directly controlling the grid, adhering to CIP principles (like strong access control and logging) is a good practice. Also, following industry security frameworks such as **NIST SP 800-53** or the **OWASP ASVS** can guide comprehensive security requirements. From a PRD perspective, explicitly listing these requirements ensures they are not forgotten – security and compliance must be treated as first-class requirements. It’s much cheaper to design in compliance from the start than to retrofit later. In agile, one might even create “security user stories” or “compliance acceptance criteria” – either way, including them here provides clear visibility. Aligning with international standards like **ISO/IEC 27001** (information security management) can be mentioned if the organization follows it. Remember, failing to meet these requirements can have legal or financial consequences, so this section should be reviewed by domain experts (security/compliance officers) for completeness.  INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile Definition‑of‑Done checklists.

## Non-Functional Requirements / Quality Attributes

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To specify the criteria that judge the operation of the system, rather than
specific behaviors. These include performance, security, usability, reliability,
and other quality attributes. Non-functional requirements (NFRs) ensure that the
product not only does *what* it should, but does so with the desired level of
quality, speed, safety, etc., which is crucial in a utility context where
reliability and safety are paramount.

Instructions:

List and describe the key non-functional requirements. It’s often useful to
categorize them by type of quality attribute. Common categories include:

* **Performance & Scalability:** Requirements about response times, throughput,
  capacity, and scalability of the system. e.g., “The system shall support 500
  concurrent users with an average response time of <2 seconds for data
  retrieval operations.” or “Must handle up to 1000 work orders per day without
  degradation.” Also consider offline performance (like app should load within X
  seconds on device).
* **Reliability & Availability:** Define uptime or availability requirements
  (e.g., “99.9% uptime during business hours” or specific acceptable downtime
  per month). Also any requirements for fault tolerance (e.g., what happens if a
  sync fails?), and data backup/recovery (important for utility data – ensure no
  data loss).
* **Security:** (Can be in its own section, but you may list basic security NFRs
  here or cross-reference the Security section below.) For example, “All data in
  transit must be encrypted (TLS 1.2 or higher)” or “User sessions expire after
  15 minutes of inactivity.”
* **Usability & Accessibility:** Requirements about the user experience – e.g.,
  “The mobile app interface shall be usable with minimal training (target: field
  users can perform main tasks after 1 hour of training).” Or “The interface
  must adhere to corporate UX standards (fonts, colors) for consistency.” If
  accessibility is important: “The product should meet WCAG 2.1 AA guidelines
  for accessible design, to accommodate color blindness and screen reader
  usage.”
* **Maintainability & Extensibility:** e.g., “The system shall be built using
  modular architecture to allow future enhancements (like adding new task types)
  with minimal refactoring.” Or maintainability metrics such as “Important: Code
  will follow internal coding standards and will include unit tests for at least
  80% of new code.” These might not always be in a PRD (sometimes they’re in an
  engineering plan), but for internal projects it’s often relevant to note.
* **Compatibility:** e.g., “Must be compatible with Chrome and Edge browsers
  (latest two versions) for the web part,” or “Mobile app must support iOS 15
  and later.” Also any backward compatibility or data migration from old systems
  if relevant.
* **Regulatory/Compliance (non-functional aspects):** Some compliance
  requirements impose NFRs, like data retention (e.g., “System must retain field
  data for at least 5 years to meet regulatory audit requirements”) or audit
  logging (“System shall log all user actions related to work order completion
  for audit purposes”). If not covered in the Security & Compliance section,
  include them here.
* **Localization:** If the app will be used in multiple locales or languages
  (likely not for an internal utility app in California, but if Spanish support
  is needed for some employees, mention that).
* **Other**: Any other quality requirements such as **Safety** (for example,
  “The software shall not distract the driver: if tech is driving, app locks
  certain features” – a safety requirement relevant to a utility where crews
  drive; or “Follow OSHA guidelines for electronic devices usage in hazardous
  areas” if any), or **Environmental conditions** (e.g., “Tablet screen must
  remain readable in bright sunlight” – which is more of a hardware spec but can
  be noted).

Use bullet points, each starting with the category or a short name of the NFR
followed by the specific requirement. Provide measurable criteria where possible
(e.g., actual numbers for performance, dates for retention, etc.).

Example:

* **Performance:** The mobile app shall load the day’s work orders in **under 5
  seconds** on average (when online). The system backend must support processing
  **up to 100 work order updates per minute** during peak usage (morning
  dispatch), without errors.
  * **Given** the Field Technician logs into the mobile app during active
    network connectivity and has one or more work orders assigned for the day,
    **When** the technician opens the “Today’s Work Orders” screen,
    **Then** the list of work orders shall load and render within **5 seconds**
    on average.
  * **Given** the backend server is processing incoming updates from the field
    during peak morning hours (e.g., 7–9 AM),
    **When** up to **100 work order updates per minute** are submitted
    simultaneously,
    **Then** the system shall accept and persist all updates without producing
    errors,
    **And** the average processing latency shall remain within operational
    thresholds (e.g., under 1.5s per request).
* **Availability:** The system (server side) should achieve **99.5% uptime**
  during 6am-6pm Monday-Saturday (field operation hours). Scheduled maintenance
  windows must be communicated and preferably performed off these peak hours.
  The mobile app shall allow offline operation for at least **8 hours** and
  queue data for later sync to ensure continuous work in case of network outages
  (supports reliability in the field).
  * **Given** it is between 6:00 AM and 6:00 PM on Monday through Saturday,
    **When** a field technician or supervisor attempts to connect to the system,
    **Then** the backend service shall be available at least **99.5%** of the
    time without interruption.
  * **Given** maintenance is required for the backend infrastructure,
    **When** a scheduled window is planned,
    **Then** it shall be communicated to all users in advance and occur
    **outside field operation hours** when possible.
  * **Given** the mobile app is offline due to poor signal,
    **When** a technician performs updates for up to **8 hours**,
    **Then** the system shall store all data locally and queue it for sync once
    network connectivity returns.
* **Security:** All API communication between the mobile app and backend will
  use **TLS 1.2+ encryption**. Sensitive fields (e.g., crew personal info, if
  any) should be encrypted in the database. The application must enforce
  **Multi-Factor Authentication** on login when off-site (in line with corporate
  security policy).
  * **Given** a technician is using the mobile app,
    **When** the app communicates with the backend API,
    **Then** all requests and responses shall be encrypted using **TLS 1.2 or
    higher**.
  * **Given** a user’s session contains sensitive data (e.g., personal crew
    info),
    **When** it is written to the backend database,
    **Then** all sensitive fields shall be **encrypted at rest** using approved
    encryption methods.
  * **Given** a user is attempting to log in from an off-site location,
    **When** authentication is initiated,
    **Then** the application shall enforce **multi-factor authentication** per
    corporate policy.
* **Usability:** The app’s UI shall be **simple and uncluttered**, with large
  buttons suitable for use with gloves. Use of text input is minimized
  (preferring picklists, voice-to-text, or scanning where possible) to
  accommodate field conditions. The design will follow the company’s UI style
  guide for consistency. New users (field techs) should be able to perform basic
  functions (view tasks, update status) with **no more than 1 hour of
  training**.
  * **Given** the Field Technician is operating in a harsh environment (e.g.,
    gloves, bright sunlight),
    **When** they use the mobile app,
    **Then** the UI shall display **large, accessible buttons** and avoid small
    or cluttered elements.
  * **Given** an input is required,
    **When** the user selects or enters data,
    **Then** the system shall prefer **picklists, voice input, or barcode
    scanning** over free-text entry.
  * **Given** a new technician is onboarded,
    **When** they are trained for 1 hour or less,
    **Then** they shall be able to **view assigned tasks and update task status
    without assistance**.
* **Accessibility:** (If applicable) The web portal shall meet **WCAG 2.1 AA**
  standards – for example, it should support screen readers for visually
  impaired office staff and have sufficient color contrast. (Mobile app should
  at least have scalable text and colorblind-friendly icons.)
  * **Given** a visually impaired user accesses the **web portal**,
    **When** they use screen reader software,
    **Then** the portal shall **meet WCAG 2.1 AA standards**, including labeled
    form fields, navigation hints, and alternative text for icons.
  * **Given** a colorblind user opens the mobile app,
    **When** viewing task status indicators or buttons,
    **Then** icons shall include **textual or shape-based cues**, and all color
    usage shall maintain a **minimum contrast ratio of 4.5:1**.
  * **Given** a user requires larger text,
    **When** system font scaling is enabled on the device,
    **Then** the app shall honor accessibility settings and **scale UI text
    appropriately** without layout breakage.
* **Maintainability:** The solution should be built on **standard
  company-supported frameworks**. All code will include documentation comments.
  We will also provide an **admin interface** for common configurations (so
  changes like adding a new work order type don’t require a code change).
  * **Given** the system is deployed and in active use,
    **When** engineers review the source code,
    **Then** all components shall follow **company-supported frameworks** and
    include **documentation comments** in-line.
  * **Given** an administrator needs to configure a new work order type or
    region,
    **When** they access the admin panel,
    **Then** such settings shall be **available without requiring a code change
    or deployment**,
    **And** the configuration shall be audit-logged and version-controlled.
* **Data Retention:** All work order completion records must be stored for **at
  least 5 years** in the central database to comply with regulatory
  record-keeping requirements. Audit logs of user actions should be retained for
  **1 year**.
  * **Given** a technician completes a work order,
    **When** the data is synced with the backend,
    **Then** the work order record shall be **retained in the central database
    for no less than 5 years**.
  * **Given** a user performs actions within the system (e.g., edit, delete,
    assign),
    **When** those actions occur,
    **Then** an **audit log entry** shall be created and retained for a
    **minimum of 1 year**,
    **And** these logs shall be searchable by Admin users for compliance or
    troubleshooting.
* **Interoperability:** The system should use standardized data formats (e.g.,
  JSON for APIs with field naming aligned to industry standards where possible)
  so that future integrations (such as with analytics tools or external
  contractors’ systems) can be done with minimal transformation.
* **Given** a third-party system or future integration is added (e.g.,
  analytics, contractor apps),
  **When** it interfaces with the backend APIs,
  **Then** all APIs shall return and accept data in **JSON format** with field
  names aligned to industry standards.
* **Given** another system consumes exported work order data,
  **When** the export is generated,
  **Then** the data shall be easily **parseable without custom transformation**,
  **And** should require minimal mapping to external schemas.

Prerequisites:

* Consult corporate **IT non-functional requirements guidelines** or checklists
  (many organizations have a security checklist, performance criteria, etc., for
  new applications).
* Involve specialists: e.g., Performance engineers for load expectations,
  Security team for specific security requirements, UX designers for usability
  heuristics.
* Review any **regulatory documents** for explicit non-functional mandates (like
  data retention from regulations, or specific safety rules). For a California
  electric utility, reliability standards (like not losing data) and security
  (NERC CIP) are often mandated.
* Determine usage assumptions: how many users, how often they’ll use it, which
  informs performance and capacity requirements.

### Standards and Best Practices

Covering a broad range of quality attributes aligns with industry standards like
**ISO/IEC 25010** (which defines product quality characteristics such as
reliability, performance efficiency, usability, security, maintainability,
portability, etc.). Ensuring each of these relevant attributes is addressed
helps create a well-rounded product. For example, **reliability** is critical
for utility software – downtime can affect operations, so stating uptime
requirements is important. **Security** standards (e.g., following OWASP Top 10
for web/mobile security) should be referenced if applicable. Many organizations
also adhere to **NIST** guidelines for cybersecurity and data protection – our
PRD’s security NFRs should reflect those. By specifying these NFRs, we provide
clear criteria for acceptance: the product isn’t done just when features are
built, but when it meets performance benchmarks, passes security tests, and so
on. INVEST & BDD guidelines; IEEE 829 / ISO 29119 for test documentation; Agile
Definition‑of‑Done checklists.

## Product Architecture Overview

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Present the high‑level technical architecture—major components, data flows, and architectural patterns—so that engineers share a common blueprint and non‑technical stakeholders grasp how the solution hangs together.

Instructions:

1. Architecture Diagram – Provide or link to a C4‑level 2 or UML component diagram (PNG/SVG) showing mobile app, backend services, data stores, external systems.
2. Component Descriptions – List each component with purpose, tech stack, key patterns.
3. Integration Points – Describe protocols (REST/JSON, MQTT, message bus), authentication method, expected SLAs.
4. Patterns & Tactics – Mention architectural patterns (micro‑services, offline‑first sync, CQRS, event sourcing) and quality‑attribute tactics (retry logic, circuit breaker).
5. Deployment View – Note hosting (Azure App Service, on‑prem K8s, etc.) and CI/CD pipeline outline.
6. Security Zones – Identify trust boundaries (DMZ, internal subnet, device).
7. Keep this section brief; deeper detail belongs in a separate Solution Architecture Document (SAD) referenced here.

Example:

**Components**

* Mobile App (iOS/Swift UI) – Presentation + local SQLite cache + sync engine using offline‑first pattern.
* API Gateway (Azure APIM) – Single entry point, JWT validation, request throttling.
* Work‑Order Service (Java/Spring Boot) – Stateless micro‑service exposing REST endpoints, communicates with Maximo via vendor API adapter.
* Sync Service (Node.js) – Handles delta sync, conflict resolution, pushes WebSocket notifications.
* Reporting Service (Python/FastAPI) – Generates PDF/Excel via queued jobs, stores files in Blob Storage with SAS tokens.
* AuthN/AuthZ – Azure AD B2E + OAuth 2.0; roles mapped from AD groups.
* Oracle DB 19c – Authoritative store for mobile‑captured data and audit logs.
* Logging & Monitoring – ELK stack + Azure Monitor; dashboards for uptime, latency, error rates.

**Patterns Used**

* Micro‑service architecture with API Gateway.
* Event‑driven messaging (Azure Service Bus) for decoupled sync and reporting.
* Offline‑first with conflict‑resolution strategy (last‑write‑wins + supervisor override).
* Infrastructure as Code (Terraform) and blue‑green deploy for zero‑downtime releases.

Prerequisites:

* Alignment with enterprise architecture principles.
* Selection of hosting option (cloud/on‑prem).
* Security review of proposed patterns (e.g., event bus encryption, API rate‑limiting).

Standards & Best Practices:

C4 model, ISO/IEC/IEEE 42010 (architecture description), Azure Well-Architected Framework, NIST Cloud Security guidance, **TOGAF (The Open Group Architecture Framework)**.

## Assumptions & Dependencies

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To document assumptions that have been made during requirements definition and any external dependencies that the project or product has. This section highlights things that are believed to be true (but not yet confirmed) and what the product relies on, so that risks can be identified if assumptions turn out false or if dependencies change. It helps in risk management and planning by making these factors explicit.

Instructions:

* **Assumptions:** List any assumptions about users, technology, business processes, or external conditions that are relevant to the requirements. These are conditions we assume to be true without concrete proof, often because they are outside the project’s immediate control or will be validated later. For example:

  * Assumptions about **user behavior or availability**: “We assume field technicians will have a company-issued tablet to use this app” or “Assume users will have basic training on mobile device use.”
  * Assumptions about **operational environment**: “Assume cellular network coverage is available at least 80% of the time in service territory” (for offline design justification).
  * Assumptions about **project support**: “It is assumed that the necessary funding and resources (developers, testers) will be available throughout the project per the schedule.”
  * Assumptions about **data**: “We assume that the quality of data from the Work Management System (e.g., equipment IDs, locations) is high, and no extensive data cleanup is required prior to integration.”
  * Any assumption about **user acceptance**: “We assume field users will adopt the new app if it meets their needs; change management will be handled by operations team.”
* **Dependencies:** List external dependencies that the project relies on. These could be:

  * **Systems/Software Dependencies:** e.g., “Depends on the GIS mapping service provided by XYZ; if that service is down, mapping features won’t work.” Or “We rely on the corporate Oracle database environment – our project is dependent on the IT infrastructure team to provision a database instance.”
  * **Team/Resource Dependencies:** e.g., “The project depends on the Networking team to open firewall access for mobile devices,” or “Dependency on vendor ABC to deliver the API for the Work Management System by July 2025.”
  * **External Events:** e.g., “Deployment of this app depends on completion of another project (like an API development project or a device rollout project).”
  * **Compliance Dependencies:** e.g., “Awaiting regulatory approval of using cloud for this data – project depends on legal clearance.” (This could be considered a risk too, but if it’s something like needing a sign-off, list it.)
  * **Integrations:** if integration with a third-party software is needed, that’s a dependency (and possibly the third-party’s timeline/availability is a factor).
* For each item, you can add a note on the impact or plan: e.g., “If this assumption fails (e.g., if technicians don’t have devices), then \[what’s the contingency].” Or for dependencies, note the expected delivery, e.g., “WMS API – expected by Q3 2025 from integration team.” This overlaps with risk management, but at least stating them clearly is the first step.

Example:

* **Assumptions:**

  * It is assumed that **field technicians will have internet connectivity** at least 80% of their work time. The app’s offline mode is designed for brief outages, not days of no connectivity. If connectivity is significantly worse, requirements for offline data caching might need to be extended.
  * We assume **technicians will carry the company-issued tablets** during work hours. (If in reality they sometimes don’t, certain real-time features like instant notifications may not be effective.)
  * We assume the **user data in the corporate directory is up-to-date** (employee roles, etc., for role-based access). E.g., if someone’s role changes or they leave, HR updates AD promptly so the app’s access remains correct.
  * The project assumes **no major organizational change** (like restructuring of the field operations process) will occur during development that would alter fundamental requirements.
  * We are assuming **acceptance of new technology by users**: Field crews have been consulted and management assures their buy-in. (We assume adequate training and change management will be provided outside of this PRD scope.)

* **Dependencies:**

  * **Work Management System (Maximo) API:** The new app depends on the WMS team delivering a stable API. *Dependency Detail:* The integration team is scheduled to finalize the API endpoints by Aug 2025. Any delay or change in the API spec will impact our development timeline.
  * **GIS Mapping Service:** We rely on the internal GIS service (ArcGIS server) to provide map tiles and asset locations. This dependency means the app’s mapping feature is subject to the GIS service’s performance and maintenance schedule. We’ll need the GIS team’s support to ensure uptime.
  * **IT Infrastructure Provisioning:** The project depends on IT Ops to provision a production server environment (or cloud resources) by the time we start testing (Oct 2025). Any delay in provisioning could delay testing and deployment.
  * **Mobile Device Deployment:** The success of the app depends on all target users having a compatible device. The plan is for the Mobile Device team to roll out new iPads to all technicians by Dec 2025. Our training and launch assume devices are in place.
  * **External Vendor Tool (if any):** (Example scenario) If we use a 3rd-party library for PDF report generation, we depend on that vendor’s library being approved by IT Security and available for use.
  * **Regulatory Approval:** (If applicable) The app features (like digital signatures for clearance tags) might need sign-off from regulatory or safety authorities. For instance, using electronic signatures in lieu of paper might need approval from a safety standards committee – our timeline assumes this approval is granted by test phase.

Prerequisites:

* Brainstorm with the project team and stakeholders about what you are **assuming** to be true. Often assumptions hide in other discussions; it’s good to surface them.
* Identify all **external parties or systems** that our work interfaces with (other teams, vendors, etc.) to list dependencies. Check project plans or integration documents for dependencies.
* Review the plan to catch any “if this doesn’t happen, we’re blocked” items – those are dependencies or critical assumptions.
* Document any **constraints** that are actually assumptions (e.g., we might assume something won’t change – like “the legacy system will remain operational until we finish migration”).

### Standards and Best Practices

Listing assumptions and dependencies is a common practice in project and requirements documents. It allows teams to monitor these items and validate them over time. For example, PMBOK (Project Management Body of Knowledge) suggests documenting assumptions and constraints early in a project. The BABOK (Business Analysis Body of Knowledge) also highlights the importance of recording assumptions that could influence requirements. Moreover, clearly stated dependencies ensure that those responsible (other teams or vendors) are aware of the importance. It aligns with risk management standards – each assumption is essentially a risk (“if this turns out false”) that should be tracked. In agile contexts, dependencies are often managed in the product backlog or risk board, but having them in the PRD provides a one-stop overview of what the product team relies on. Regularly revisit this section: as the project progresses, confirm assumptions (or adjust if they prove false) and update the status of dependencies.

## Risks & Mitigations

[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To identify major project and product risks and outline mitigation strategies for each. While not always included in a traditional PRD, documenting key risks in this context (internal project at a utility) is a best practice to ensure awareness and proactive management. This section helps prepare the team for potential challenges that could impact the product’s success (schedule delays, budget issues, technical hurdles, adoption problems, etc.).

Instructions:

* List the **key risks** that could threaten the project’s success or the product’s effectiveness. Focus on high-impact or high-likelihood risks. Categories of risks to consider:

  * **Schedule Risk:** e.g., tight timeline, risk of delays due to dependency or resource constraints.
  * **Technical Risk:** e.g., new or unproven technology (if we’re using something new), integration complexity (WMS API might not perform as expected), performance concerns (will offline sync work with large data?), etc.
  * **Resource Risk:** e.g., key team members might be pulled away, or vendor support might be lacking.
  * **Scope/Requirements Risk:** e.g., risk of scope creep (stakeholders might want additional features mid-project), or risk that requirements change due to regulatory changes.
  * **User Adoption Risk:** e.g., field technicians might resist using the new app if not user-friendly or if training is insufficient.
  * **Compliance/Security Risk:** e.g., risk of a security breach if not properly secured, or risk of not meeting a compliance deadline if project slips.
  * **External Risk:** e.g., regulatory approval taking longer, or supply chain issues (if depending on hardware).
* For each risk, provide a brief **description** and then a **mitigation or contingency** plan. Mitigation is what you’ll do proactively to reduce the probability or impact of the risk. Contingency is what you’ll do if the risk event occurs. For this template, you can combine them in one statement if clear.
* Optionally, assign a **risk level** (High/Med/Low) or probability/impact score if your process uses that. This helps prioritize attention.
* The format can be bullet points or a table. A simple format is: **Risk:** description **Mitigation:** what we’ll do. Or separate line bullets for risk and mitigation.
* Ensure the risks listed are those that a PRD reader (developers, stakeholders) should be aware of; more detailed risk logs can exist elsewhere, but highlight the big ones here for visibility.

Example:

* **Risk: Integration API Delay** – *The Work Management System API might not be ready on time or might not have all required endpoints.* **Mitigation:** We are coordinating closely with the integration team with bi-weekly sync meetings. If the API is delayed, as a contingency we can develop a temporary data export/import as a fallback to keep progress, or stub the API responses for testing purposes. We’ve also scoped our development to start with features that don’t rely on the new API first, to allow buffer time.
* **Risk: User Adoption & Change Resistance** – *Field technicians might be hesitant to adopt the new app, preferring their familiar paper process.* **Mitigation:** Engage users early – include a few techs in a pilot group for feedback. Provide thorough training and ensure the app’s design is user-friendly (addressing their pain points, like offline usage and simplicity). Management will communicate the benefits and set expectations that the old process will be phased out. If adoption is slow, consider an incentive or additional support during transition (like on-site champions to help peers).
* **Risk: Performance Issues** – *The app might experience slow sync or crashes if too many work orders are handled (e.g., during storm emergencies when work volume spikes).* **Mitigation:** Set strict performance requirements (as above) and plan for load testing. If testing reveals issues, optimize code or scale up infrastructure (e.g., ensure servers auto-scale in cloud). Also design graceful degradation (maybe limiting the amount of data synced in one go). Contingency: have a manual process fallback for extreme cases (like if app is overwhelmed during a major emergency, techs might revert to radio communication until system catches up – not ideal but have that as a backup procedure).
* **Risk: Regulatory Compliance Change** – *New regulations or internal policy changes could introduce new requirements late (for example, a sudden mandate to log additional data for audits).* **Mitigation:** Keep compliance team in the loop throughout development to catch wind of upcoming changes. The design is being kept flexible (modular logging, etc.) to accommodate tweaks. If a new requirement emerges late, we may need to re-prioritize features or possibly schedule a follow-up release to address it.
* **Risk: Key Person Dependency** – *Our lead developer is the only one familiar with the legacy WMS integration.* **Mitigation:** Cross-train another developer on that component and maintain good documentation of the integration. If the lead becomes unavailable, the secondary person can step in with minimal ramp-up. Also, consider engaging the vendor’s support or consulting if needed to cover knowledge gaps.
* **Risk: Budget or Timeline Overrun** – *If we under-estimated the effort, we might run out of budget or time.* **Mitigation:** Use Agile iterative development to deliver core value early (minimum viable product) so that if later features slip, the most important capabilities are already delivered. Regularly monitor burn rate and progress; if we see slippage by mid-project, either de-scope lower priority features (per scope section) or secure additional budget/time from stakeholders by presenting a justified case.

Prerequisites:

* Conduct a risk workshop with the team and possibly stakeholders to brainstorm what could go wrong. Many risks might have been mentioned already in meetings or earlier sections (assumptions often point to risks if wrong).
* Use organizational knowledge: e.g., check past similar projects for typical risks (maybe adoption was an issue before, or integration took longer, etc.).
* Identify existing **mitigation plans** or strategies from company best practices (for example, the company might always do a pilot to mitigate user adoption risk – include that).
* Ensure you have management support for the mitigation actions that require resources (like extra training sessions, load testing infrastructure, etc.).

### Standards and Best Practices

Proactively listing risks in a PRD underscores a culture of planning and quality. Agile methodologies encourage addressing risks early (spikes, proof-of-concepts to mitigate technical risks). Traditional PM frameworks (PMBOK) have entire processes for risk management; summarizing the top risks in this doc means they’re visible to all stakeholders reading it. It’s noted that a good PRD can also act as a tool for **risk mitigation** by identifying challenges early. Many successful teams use the PRD review as a chance to discuss “what could go wrong” – capturing those results here. While the PRD is mainly about requirements, including a risk section (especially for an internal critical project) is considered a best practice by many product leaders to ensure everyone is mindful of challenges ahead. The goal is to reduce the likelihood of surprises later, thereby avoiding costly delays or failures.

## Open Questions / Issues Log

#[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

Track unanswered questions and pending decisions so that nothing critical is
overlooked and owners are accountable for resolution.

#Instructions:

1. Maintain a rolling list with ID, Question, Owner, Needed‑by Date, Status.
2. Review at each sprint planning or stakeholder meeting.
3. Promote resolved items to assumptions, requirements, or risks sections as
    appropriate.
4. Archive closed questions to keep the list concise.

#Example:

| **ID** | **Question**                                            | **Owner**     | **Needed-by** | **Status**     |
|--------|---------------------------------------------------------|---------------|---------------|----------------|
| Q-01   | Will field techs require electronic signature capture?  | Ops Mgr.      | 2025-07-12    | OPEN           |
| Q-02   | Can we reuse existing ArcGIS licence seats?             | GIS Lead      | 2025-07-05    | ANSWERED — Yes |
| Q-03   | What is the maximum photo size supported by Maximo API? | Vendor Rep    | 2025-07-18    | PENDING        |
| Q-04   | Does Legal approve storing limited PII on tablets?      | Legal Counsel | 2025-07-25    | OPEN           |

#Prerequisites:

* A facilitator (Product Mgr.) to curate and chase answers.
* Agreement from stakeholders to supply timely responses.

#Standards & Best Practices:

PMBOK issue‑log practice; Agile “parking lot” technique; RACI for ownership
clarity.

## Supporting Materials

### Appendix & References

#[SECTION INSTRUCTIONS — DO NOT OUTPUT]
Purpose:

To provide any additional information, supporting materials, or references to external documents that are relevant to the PRD. This section ensures that readers can find further details or source materials if needed, without cluttering the main sections. It can include glossaries, detailed data, or links to other documents like design specs or regulatory texts.

#Instructions:

* **References:** List documents, web links, or resources that were used as inputs for this PRD or that the reader might consult for more information. This may include:
  * Related requirement documents (e.g., a higher-level Market Requirements Document if one exists, or a Vision & Scope document).
  * Technical specifications or API documentation for systems we integrate with (e.g., “Maximo WMS API Guide, version 1.2”).
  * Corporate policies or standards referenced (e.g., “IT Security Policy Manual, rev 2025” or “UI Style Guide v3”).
  * Regulatory documents (e.g., “NERC CIP standards version X” or “CPUC General Order for record-keeping”).
  * User research or survey results if any (maybe a summary report of a field user survey that influenced requirements).
  * Any external standards (ISO, IEEE) or industry guidelines that were referenced.
* For each reference, provide enough detail for someone to find it: title, version/date, and where/how to access it (a URL or repository path, etc.), as per standard practice. If it’s an internal doc not broadly accessible, note the contact or location.
* **Glossary:** (if applicable) Define any abbreviations, acronyms, or domain-specific terms used in the PRD. For a utility, acronyms like “WMS (Work Management System)”, “GIS (Geographic Information System)”, “NERC CIP”, etc., may need explanation. List each term with a brief definition. This is very helpful for new team members or stakeholders not familiar with all jargon.
* **Additional Details:** You can include any supplementary details that didn’t fit in main sections. For example, detailed tables, or raw data that support a requirement. E.g., a table of user roles and permissions (if not already covered), or a copy of a survey result chart, etc. Keep in mind the medium – if this is Markdown text, large tables may be a bit unwieldy; consider if it’s better as a separate document.
* **Design Artifacts:** If wireframes, mockups, or process flow diagrams exist, list them here (or link to them). E.g., “See Wireframe\_v1.pdf for preliminary UI design of the mobile app.” In an online documentation system, you might embed images or links. (Ensure these are accessible to the team).
* Clearly separate each part (you can use subheadings within Appendix if multiple types of info, like “Glossary” as a sub-section).

#Example:

**References:**

* *Utility Mobile App Survey Results* – Analysis report of field technician survey, PowerCo UX Team, March 2025. (Available on the internal SharePoint: `\\Company\Research\FieldSurvey2025.pdf`)
* *Maximo Work Management System – API Documentation v1.2* – Provided by Maximo vendor, June 2025. (Internal Confluence page “Maximo API Guide”).
* *IT Security Policy Manual* – Rev. 2025, Section 5.2 “Mobile Device Security Requirements” used for encryption/password policies.
* *NERC CIP Standards* – NERC CIP-003 through CIP-011 (Version 5) guidelines for cyber security of BES Cyber Systems. Relevant portions (like CIP-007 Logging) were referenced. Official documentation is available on NERC’s website.
* *IEEE 830-1998 SRS Standard* – Used for general guidance on good requirements practices (e.g., qualities of requirements).
* *ISO/IEC 25010:2011 (Software Product Quality)* – Referenced for defining quality attributes categories.
* *Corporate UI Style Guide* – “PowerCo Digital Style Guide v3”, June 2024, by UX Team (contains design standards for internal apps).
* *Project Charter: Field Service App* – Initial project charter approved Jan 2025 (includes high-level budget, initial scope outline).

**Glossary:**

* **PRD:** Product Requirements Document. This document outlining product requirements.
* **WMS:** Work Management System. The existing system (Maximo) that manages work orders, which the new app will interface with.
* **GIS:** Geographic Information System. Used to provide mapping and geolocation services (e.g., showing work order locations).
* **NERC CIP:** North American Electric Reliability Corporation’s Critical Infrastructure Protection standards – rules that govern cybersecurity for the electric grid.
* **CIP-007:** A specific NERC CIP standard dealing with system security management (mentioned in context of logging and patch management).
* **CPUC:** California Public Utilities Commission – state regulator that may set requirements our utility must follow.
* **MFA:** Multi-Factor Authentication – a security measure requiring multiple forms of verification to log in.
* **UAT:** User Acceptance Testing – a phase where end users test the system to ensure it meets their needs before full deployment.
* **MVP:** Minimum Viable Product – a version of the product with just enough features to be usable and deliver value, used to gather feedback for improvement.
* **INVEST:** A mnemonic for good user stories (Independent, Negotiable, Valuable, Estimable, Small, Testable).

**Additional Notes:**

* **Future Enhancements:** (Optional to note) Some features considered out-of-scope now could be revisited later. E.g., integration with Inventory System for parts tracking is a potential Phase 2 item. Stakeholders have expressed interest, so though it’s out-of-scope, it remains in the backlog for future discussion.
* **Decision Log:** (Optional) Significant decisions made during requirements development (like choosing an on-prem solution vs cloud, or deferring a certain feature) are documented in the project’s decision log, referenced here for completeness (See Confluence page “FieldApp Decisions”). This helps anyone reading the PRD understand why certain choices were made if there’s ever confusion.

#Prerequisites:

* Ensure all documents and resources referenced are accessible to the team (permissions in place).
* Double-check that acronyms used throughout the PRD are captured in the glossary.
* Review if any content was deferred from main sections to appendix (for example, if you had a very detailed table that didn’t fit nicely in a section, make sure it’s attached or referenced here).

#### Standards and Best Practices

Including references in a requirements document is part of IEEE recommendations – it provides traceability to source materials and clarifies the basis of requirements. A glossary is highly recommended by many technical writing standards to ensure common understanding, especially in cross-functional teams (it prevents confusion over terms and acronyms). By following this approach, the PRD remains focused yet doesn’t lose important supplementary information. International standards for documentation (like ISO/IEC/IEEE 26513 for documentation) encourage providing references and glossaries for completeness. This section will help new team members or auditors (if they ever review the requirements) to find background information and understand domain-specific language used in the PRD.

Copy and Open ChatGPT Copy and Open Claude Copy and Open GitHub Copilot Copy and Open Microsoft Copilot

Provider actions copy the prompt to your clipboard and open only the provider’s home page. The prompt is never placed in a URL.

About This Prompt

Product Requirements Document Template

Use one template to draft an internal utility software PRD, perform a quality review, or analyze the impact of a review finding or proposed change. Provide the source documents, the requested operation, and any existing PRD. The prompt preserves attachment citations, explicit unknowns, metric instrumentation, anti-goals, release phases, and operating responsibilities.

The creation mode combines the expanded measurement guidance from Template 2 with the input and output controls from Template 4. Quality review preserves the separate quality, clarity, completeness, and next-step assessments.

Available Modes

The numbered PRD variants are maintained here under one stable catalog identity.

Includes the Architecture Product Requirements Document (PRD) Template 2 workflow by Ted Tschopp. Original source.
Includes the Architecture Product Requirements Document (PRD) Template 3 workflow by Ted Tschopp. Original source.
Includes the Architecture Product Requirements Document (PRD) Template 4 workflow by Ted Tschopp. Original source.

Use this entry for the maintained workflow and current download.

Continue Exploring

Browse the Full Library

A faceless wooden steward arranges blank cyan-edged plan pieces around a small architectural model.

Prompt Template Fileactive

Architecture PRD Agent

Professional architecture prd agent prompt designed for high-quality content generation and structured analysis.

ChatGPTClaudeGitHub Copilot+1

Planning and DeliveryContent and DocumentationAI and Agents

Ted Tschoppprd-agent.prompt.md▲ 0↓ 0

A navy hand press transforms a cyan clay form into a bound stack of blank structured paper sheets.

Prompt Template Fileactive

Architecture PRD Generator

Professional architecture prd generator prompt designed for high-quality content generation and structured analysis.

ChatGPTClaudeGitHub Copilot+1

Planning and DeliveryContent and Documentation

Ted Tschoppprd-generator.prompt.md▲ 0↓ 0

A navy platform connects four tactile workflow modules with cyan channels and an orange keystone.

Prompt Template Fileactive

Architecture Product Requirements Document (PRD) for Power Platform

Professional architecture product requirements document (prd) for power platform prompt designed for high-quality content generation and structured analysis.

ChatGPTClaudeGitHub Copilot+1

Planning and DeliveryContent and Documentation

Ted Tschoppproduct-requirements-document-prd-for-power-platform.prompt.md▲ 0↓ 0

Product Requirements Document Template

Customize This Prompt

Prompt

About This Prompt

Product Requirements Document Template

Available Modes

Architecture PRD Agent

Architecture PRD Generator

Architecture Product Requirements Document (PRD) for Power Platform

Rate and Discuss This Prompt Template File

AI.Tedt.org Discussion

Customize This Prompt

Prompt

About This Prompt

Product Requirements Document Template

Available Modes

Related Assets

Architecture PRD Agent

Architecture PRD Generator

Architecture Product Requirements Document (PRD) for Power Platform

Rate and Discuss This Prompt Template File

AI.Tedt.org Discussion