Fastplan

Inspiration

Software development often stalls before a single line of code is written. The "Blank Canvas Problem" plagues Product Owners and Scrum Masters. Staring at an empty Jira backlog and manually typing out Epics, User Stories, and Acceptance Criteria is tedious, time-consuming, and prone to inconsistency.

We realized that while Jira is excellent for tracking work, there was a gap in planning work. We wanted to build a "Virtual Product Owner"—an AI agent that doesn't just chat, but actively structures project requirements into actionable Jira issues. FastPlan was born to turn the 4-hour backlog grooming session into a 5-minute review process.

What it does

FastPlan is a native Jira Project Page app that transforms vague ideas into a fully populated, sprint-ready backlog.

Prompt-to-Plan Engine: The user simply types a high-level idea (e.g., "Create a CRM for a law firm"), selects a complexity level (MVP, Standard, or Enterprise), and chooses an AI model.

Structured Output: It doesn't just dump text. It generates a strict hierarchy of Epics, User Stories, and Subtasks.

Deep Details: For every User Story, the AI automatically assigns a Priority (High/Medium/Low) and writes detailed Acceptance Criteria in standard format, ensuring developers know exactly what "Done" looks like.

Hybrid Workflow: We know AI isn't perfect. That's why we built a UI that allows users to seamlessly mix AI-generated tasks with Manual inputs before creation.

One-Click Execution: Once confirmed, FastPlan calls the Jira API to create all issues, linking Stories to Epics and Subtasks to Stories automatically.

How we built it

We architected FastPlan strictly on the Atlassian Forge platform to ensure security and native integration.

Platform: Atlassian Forge (Custom UI) for hosting and runtime.

Frontend: React.js coupled with Atlaskit (Atlassian Design System) to ensure the app looks and feels like a native part of Jira.

AI Engine: OpenAI API (GPT-4o and GPT-4o-mini) via Forge Resolvers. We used advanced System Prompt Engineering to enforce strict JSON output structures and Gherkin-style Acceptance Criteria.

Backend: Node.js (Forge Runtime) handling secure API calls and orchestrating the Jira REST API for issue creation and linking.

Challenges we ran into

React State & The "White Screen of Death": We faced significant issues with React rendering crashing due to asynchronous state updates when handling dynamic inputs (the "null value" errors). We had to implement rigorous defensive coding patterns and optional chaining to stabilize the UI.

Jira ADF Complexity: Converting AI text responses into Jira's Atlassian Document Format (ADF) for descriptions was tricky. We had to write parsers to correctly format Acceptance Criteria as bulleted lists within the Jira issue description.

Context Hallucinations: Early on, the AI would generate tasks that didn't make sense for the selected complexity. We solved this by implementing strict "Persona" instructions in the system prompt for MVP vs. Enterprise levels.

Accomplishments that we're proud of

Seamless Hierarchy Linking: Successfully automating the parent-child relationship (Epic -> Story -> Subtask) via the API. It sounds simple, but managing the async creation order to ensure IDs are available for linking was a complex logic puzzle.

The "Hybrid" UI: We are proud that our app isn't just a "Generate button." The ability for users to verify, select/deselect, and inject manual tasks before the API call makes it a practical tool for real-world use, not just a toy.

Zero Infrastructure: Building this entirely on Forge means we don't manage any servers. The app scales automatically with Atlassian's infrastructure.

What we learned

Defensive Programming is Non-Negotiable: When working with Generative AI, you cannot trust the output structure 100%. Your frontend code must handle missing fields or malformed JSON gracefully.

Prompt Engineering is Coding: We learned that changing the system prompt is just as impactful as changing the Javascript logic. Being specific about "Acceptance Criteria" formats drastically improved the quality of the output.

Forge Permissions: Navigating the specific scopes (read:jira-work, write:jira-work) required for different API endpoints taught us a lot about Atlassian's security model.