Client Project Manager for Jira

Manage SOWs, track billable vs. non-billable time, forecast budgets, and plan team capacity - all natively in Jira. Built for consulting firms and agencies.

Comment

Client Project Manager for Jira: Project Story

Inspiration

It started on a mountain summit after a beautiful hike. One of our team members pulled out their iPhone and started jotting down requirements. Random thoughts about features, Forge capabilities, integration points. The kind of scattered notes that usually take weeks to refine into something actionable.

By the next morning, those notes had transformed into a fully fleshed-out Forge app with complete architecture, 31 planned stories across sprint cycles in Jira, comprehensive technical documentation, and a project our entire team could start building immediately.

Rovo Dev CLI became our co-pilot for the entire journey.

When Codegeist 2025: Atlassian Williams Racing Edition launched, our team at Atlas Bench knew exactly what we wanted to build. We've spent years helping consulting firms automate their project delivery workflows with sophisticated custom solutions inside Jira and Confluence. Capacity tracking, billable hours, automated reporting, and keeping everyone aligned from delivery teams to customers to accounting.

Marketplace apps exist, but they require extensive customization and still involve manual work, even for tasks that should be automated. Our clients struggle with this fragmented experience every day.

We decided to translate our approach into a Forge app for Codegeist: perfect timing, real problem, innovative solution.

What It Does

Client Project Manager for Jira transforms how consulting firms and agencies manage client work:

Global SOW Management

  • Create and manage Statements of Work with full financial tracking
  • Hierarchical SOW structures (programs to projects to deliverables)
  • Map Jira issues directly to SOWs for automatic time rollup
  • Works with Jira's native time tracking field, so it integrates with any time tracking software that supports Jira

Financial Visibility

  • Track billable vs. non-billable hours across your organization
  • Calculate profit margins with client billing rates and internal costs
  • Budget forecasting with burn rate analysis

Capacity Planning

  • Team utilization dashboards with configurable assumptions
  • Identify over-allocated and under-utilized resources
  • Project capacity gaps before they become problems

Project-Level Insights

  • Calendar view with workload indicators (light, healthy, heavy)
  • Breakdown by user, issue type, and work item
  • Exportable reports in multiple formats

Role-Based Permissions

  • Control financial visibility by user and project
  • Configurable billable issue types at global and project levels
  • Admin panel for organization-wide settings

How We Built It

Rovo Dev as a True Teammate

There we were on that mountain, taking in the breathtaking view, ideas flowing. Phone out, capturing everything: feature requirements, user workflows, technical constraints. By the time we got back down, we had pages of scattered notes.

Then Rovo Dev CLI became our teammate, not just for planning, but for the entire development journey.

Over the course of this project, we utilized over 10 million tokens through Rovo Dev CLI. That's not a typo. This wasn't a quick prototype. It was a comprehensive, iterative development process where Rovo Dev was involved in every phase: planning initiatives and epics, writing stories with full acceptance criteria, creating technical architecture documents, organizing sprint cycles in Jira, maintaining living documentation, and building production code across multiple modules.

We brought our experience building on Forge since its 2021 GA release. Rovo Dev brought tireless assistance, perfect context retention, and the ability to iterate rapidly.

  • When we mapped out cross-project visibility, it documented it in Confluence
  • When we outlined automation workflows, it created the Jira stories
  • When we sketched permission structures, it built the implementation plan
  • When we hit technical blockers, it helped debug and refactor
  • When we needed comprehensive demo data, it generated realistic datasets

The Tech Stack

Platform:       Atlassian Forge
Frontend:       React + Custom UI with Webpack bundling
Backend:        Forge Resolvers + Atlassian Forge SQL
APIs:           Jira REST API v3, Confluence REST API
UI Components:  Atlassian Design System (Atlaskit)
AI Assistance:  Rovo Dev CLI + Claude Code

Architecture Highlights

  • Atlassian Forge SQL for persistent storage of SOWs, configurations, and user roles
  • Custom UI (not UI Kit) for full React control and complex dashboard layouts
  • Multi-module structure: Global admin panel, project pages, and settings views
  • Demo mode with comprehensive sample data for onboarding and showcasing

Challenges We Faced

1. Complex State Management Across Views

With multiple dashboards (analytics, capacity, billable tracking, forecast), each with their own data requirements, keeping state synchronized while maintaining performance was challenging. We solved this with careful prop drilling and a demo mode that could bypass API calls entirely.

2. Hierarchical SOW Relationships

Building the parent-child SOW hierarchy with proper rollup calculations required careful data modeling. A parent SOW's progress needs to reflect all children, but without creating circular dependencies or performance issues.

3. Financial Permission Complexity

Not everyone should see revenue and cost data. Implementing role-based financial visibility that works at both global and project levels, while keeping the UI intuitive, took several iterations.

4. Demo Mode That Actually Works

Creating a demo mode with realistic sample data that populates every view correctly (18 SOWs with hierarchy, 50 worklogs across 30 days, 8 team members) required ensuring every component respected the demo flag consistently.

Accomplishments We're Proud Of

From mountain notes to production-ready. What typically takes months of planning meetings, requirement gathering, and documentation was dramatically accelerated with Rovo Dev CLI as our constant companion throughout the entire development process.

10 million tokens of collaboration. This represents hundreds of iterations, refinements, debugging sessions, and feature implementations. Rovo Dev wasn't just a planning tool. It was embedded in every phase of development.

Complete team clarity from day one. Every architectural decision is documented. Every task has full context. The Teamwork Graph keeps everyone aligned without context switching.

Real problem, real solution. This isn't a demo project. It's the app we wish existed for our consulting clients. We've already identified firms who want to pilot it.

Comprehensive demo experience. Anyone can enable demo mode and immediately understand the app's value without configuring anything or having real project data.

What We Learned

Rovo Dev CLI Changes Everything

With over 10 million tokens consumed throughout this project, we experienced what it's like to have a true AI development partner. The ability to have a teammate that:

  • Maintains context across hundreds of development sessions
  • Creates Jira stories with proper acceptance criteria
  • Documents decisions in Confluence automatically
  • Remembers architectural constraints without repetition
  • Debugs complex issues alongside you
  • Generates comprehensive test data and documentation

This isn't just faster. It's a fundamentally different way to build software. The depth of collaboration possible when your AI teammate never forgets context and never loses patience is transformative.

Forge Has Matured Significantly

Having built on Forge since 2021, the improvements are dramatic:

  • Atlassian Forge SQL makes persistent storage straightforward
  • Custom UI gives us full React capabilities
  • The developer experience has become genuinely productive

Demo Mode Is Worth the Investment

Building comprehensive demo data upfront paid dividends: easier testing, better onboarding, and a compelling way to showcase the app without requiring setup.

What's Next

Immediate Roadmap

  • Automation for Jira integration: auto-create SOWs from templates, trigger notifications on budget thresholds
  • Rovo integration: AI-powered insights and natural language queries for project health and financials
  • Atlassian Marketplace publication: making the app available to consulting firms and agencies worldwide

Built With

  • Atlassian Forge
  • React
  • TypeScript
  • Atlassian Forge SQL
  • Atlassian Design System
  • Webpack
  • Rovo Dev CLI
  • Claude Code

The Team

Atlas Bench: We help organizations transform how they work with Atlassian tools. This project represents years of consulting experience distilled into a single, powerful Forge app.

What we're building accelerates onboarding, keeps delivery teams synchronized, provides real-time visibility to stakeholders, and automates reporting. All seamlessly integrated in Jira. One system that transforms how consulting firms deliver exceptional client work.

Built With

Share this project:

Updates