DORA Metrics Dashboard

A macOS dashboard I built during my Makers Academy Software Developer Level 4 Apprenticeship to solve a real-world problem in my company: reducing PR review bottlenecks and tracking team delivery performance. Originally developed for internal use, this version uses the VS Code public repository for demonstration.

A macOS desktop application for visualizing software delivery performance metrics using the DORA (DevOps Research and Assessment) framework. Built with SwiftUI to help development teams track and improve their delivery performance.

What It Does

This dashboard connects to GitHub's API to automatically track and visualize key metrics that indicate how well a software team is performing:

Pull Request Management

Lists all open PRs that need review, ordered from oldest to newest
Color-coded urgency indicators (red for PRs >5 days old, orange for 3-5 days, blue for recent)
Filter by team to see only relevant PRs
Quick links to GitHub for immediate action

DORA Metrics Visualization

Deployment Frequency: Track releases per month with interactive bar charts
Lead Time for Changes: Measure time from PR creation to merge
Change Review Time: Average days to complete PR reviews
Interactive lollipop charts showing individual PR completion times
Breakdown by PR type (feature, fix, chore, CI, bot, others)
Team-based filtering for focused insights

Secure Configuration

Personal GitHub token authentication (stored securely in macOS Keychain)
Team and repository configuration
Token validation with visual feedback

Why I Built This

This was my capstone project for a Makers Academy Software Developer Level 4 Apprenticeship. The development team at my company was experiencing slow PR review times, and management needed visibility into DORA metrics for quarterly objectives.

Initial requirements included Jenkins integration for build status, but after researching the feasibility (VPN requirements, authentication complexity, timeline constraints), I pivoted to focus on delivering a polished GitHub integration instead. This decision saved weeks and delivered real value to the team. Sometimes knowing what not to build is as important as what to build.

Screenshots

PR Review Queue
View all open pull requests sorted by age, with team filtering to focus on relevant work.

DORA Metrics Dashboard
Interactive charts showing deployment frequency, lead time, and review time with team breakdowns.

Tech Stack

SwiftUI: Declarative UI framework for macOS
MVVM Architecture: Clean separation of concerns, highly testable
GitHub REST API: Pull request and release data
Swift Charts: Native data visualization
KeychainSwift: Secure credential storage
XCTest: Unit and snapshot testing (83% code coverage)

What I Learned

Test-Driven Development: Used the Red-Green-Refactor approach for key features like color-coding PRs by age. Writing tests first forced me to think through the problem before implementing, resulting in cleaner code. Yes, it was slower initially, but the confidence it gave me was worth it.

Dependency Injection & Mocking: Created an abstract network layer (DataServiceProtocol) to enable testing of async API calls without hitting GitHub every time. The MockResultService lets tests run fast and reliably.

Async/Await in Swift: Handled asynchronous API calls and threading (keeping UI updates on the main thread, moving Keychain operations to background threads).

Real-World Problem Solving: When I discovered the Keychain library was blocking the main thread, I debugged using Xcode's thread inspector, researched Apple's documentation, and moved those operations to background tasks. Small bug, but good learning about iOS threading.

OOP Principles: Applied single responsibility principle throughout - each ViewModel does one thing, Views know nothing about network calls, Models are pure data structures.

Project Highlights

Code Quality

83% test coverage (unit tests + snapshot tests)
CI/CD integration with Jenkins (branch protection, automated test runs on PRs)
Dependency injection pattern for testability
Clean, maintainable code following Swift conventions

User-Centered Design

Gathered feedback from developers throughout the project
Iterated on UI designs based on team input
Conducted User Acceptance Testing before final deployment
Focused on solving a real pain point (slow PR reviews)

Architecture Decisions

Chose MVVM over MVC (Apple's recommended pattern for SwiftUI)
Used Swift Charts instead of third-party libraries (native = better performance)
Researched multiple Keychain libraries before choosing KeychainSwift for simplicity
Limited data fetching to 200 PRs max (50 open, 200 closed) to optimize memory usage and API rate limits

Running the Project

Prerequisites: You'll need a GitHub personal access token (free, takes 30 seconds):

Go to GitHub → Settings → Developer settings → Personal access tokens
Click "Generate new token (classic)"
Name it "DORA Dashboard"
Select scope: public_repo (read access to public repositories)
Generate and copy the token

Setup:

Clone the repository
Open DORADashboard.xcodeproj in Xcode
Build and run (⌘R)
In the app's Settings view:
- Paste your GitHub token
- Click "Authenticate" (button turns green)
- Allow keychain access when prompted
Navigate to "PRs for Review" or "Metrics" to see live data from VS Code repository
Use the team filters to demonstrate filtering functionality (team assignments are fictional for demo purposes)

Demo Configuration: This repository uses the public VS Code repository for demonstration purposes (limited to 200 PRs for performance). The original version was deployed internally at my company with Jenkins CI/CD integration, real team structures, and internal repository tracking. Team assignments shown here are fictional placeholders. To use with your own repository, update the baseUrl in DataService.swift and team assignments in SettingsViewModel.swift. Future enhancement would add UI for configuring repositories and teams without code changes.

Testing

Run tests with ⌘U or via the terminal:

xcodebuild test -scheme DORADashboard -destination 'platform=macOS'

Tests include:

Unit tests for ViewModels (with mocked network layer)
Model tests for data structures
Snapshot tests for Views
Date calculation tests (PR age, time ranges)

Future Enhancements

Settings UI improvements: Add/remove teams and repositories without code changes
AppCenter integration: Track crash rates per release
Lead time refinement: Measure from first commit to PR creation
Time to release: Track deployment frequency (merge to production time)
Notifications: Alert when PRs exceed age thresholds

Reflections

This project taught me that software development is as much about research and decision-making as it is about coding. The Jenkins feasibility study saved weeks of wasted effort. Gathering developer feedback early shaped features that actually mattered. And using TDD, while slower at first, paid dividends when I refactored later.

The DORA metrics framework is fascinating - it's backed by years of research showing that high-performing teams excel at these four key key metrics. Building a tool to measure them gave me deeper appreciation for DevOps culture and continuous improvement.

Built December 2023 as the capstone project for my Makers Academy Software Developer Level 4 Apprenticeship

rauldelahera/dora-metrics-dashboard