AWS Builder Center

Git Wiz: Git History Visualizer

GitWiz transforms complex Git repositories into interactive visual stories, helping developers explore contribution patterns, branch evolution, and code changes in one place. Built with React, FastAPI, PostgreSQL, and AWS, it makes understanding how a codebase evolved faster and more intuitive.

The Idea

Git remembers everything about how a project was built every commit, branch, contributor, file change, and merge. But most of this history is still experienced as a list of commits or terminal commands.
GitWiz turns Git history into something developers can see, navigate, and understand.
Users simply provide a GitHub repository URL, and GitWiz analyzes the repository and transforms its history into an interactive dashboard containing a contribution heatmap, branch and commit history, and line-by-line code evolution.
Our goal is simple: make the history of a codebase as understandable as the code itself.

The Problem

Understanding an unfamiliar or long-running codebase is not just about reading its current source code. Developers often need to understand why the code looks the way it does and how it got there.
However:
  • Git history becomes difficult to navigate at scale. Commands such as  git log  and  git log --graph  are useful, but large repositories can produce overwhelming text-based histories.
  • Repository information is fragmented. Developers may need to move between commits, branches, contributor activity, and individual diffs to build a complete picture.
  • Code archaeology is time-consuming. Finding when a feature was introduced, how a branch evolved, or which commit changed a particular part of a codebase can involve manually searching through many commits.
  • A diff shows a change, but not always the story behind it. Developers can see what changed, but understanding the sequence and context of changes is harder.
This becomes especially relevant during developer onboarding, debugging, maintenance, code review, and learning from existing projects.

What We Built

GitWiz brings these different pieces of Git history together into one interactive experience.

Contribution Heatmap

The contribution heatmap provides a visual overview of repository activity over time. Instead of manually counting commits or scanning logs, users can immediately identify periods of high and low development activity.

Interactive Branch & Commit History

GitWiz converts the repository's commit topology into an interactive history tree.
Users can visually follow:
  • Branch creation and divergence
  • Commit progression
  • Merges
  • Relationships between commits
  • Different development paths
This provides context that is difficult to obtain from a flat commit list.

Code Evolution & Playback

Selecting a commit takes the user directly to its code changes.
Additions and deletions are clearly distinguished, while the playback feature presents changes line by line, allowing users to watch how a piece of code evolved rather than simply viewing the final result.
This is particularly useful when trying to understand how and when a feature or change was introduced.

How It Works

GitWiz follows a full-stack client-server architecture.

Frontend : React + TypeScript + Vite

The frontend provides the interactive visualization layer and handles:
  • Repository submission
  • Contribution heatmap
  • Commit and branch visualization
  • Commit selection
  • File and diff viewing
  • Line-by-line playback
  • API integration

Backend : Python + FastAPI

The backend handles repository ingestion, Git analysis, data processing, and API delivery.
A key part of our implementation is our Git ingestion engine, which interacts directly with Git repositories using Git CLI commands through Python's  subprocess  module.
It processes:
  • Commit hashes and metadata
  • Parent-child relationships
  • Branches and tags
  • Contributors and timestamps
  • File changes
  • Additions and deletions
  • Commit trees
  • Historical diffs
The processed metadata is exposed to the frontend through REST APIs.

Database : PostgreSQL

PostgreSQL stores structured repository metadata such as repositories, commits, authors, branches, tags, parent relationships, and file changes.
The actual Git repository is retained separately so that detailed historical operations, such as retrieving commit diffs, can be performed directly against the Git data.

Architecture

User
↓
React + TypeScript Frontend
↓
FastAPI Backend
↙         ↘
Git Repository   PostgreSQL

AWS: From Local Project to Deployed Application

We used AWS to take GitWiz beyond a local development environment and make it accessible as a deployed full-stack application.

Amazon EC2

We deployed the application on an Amazon EC2 Ubuntu instance.
The EC2 server hosts:
  • React production build
  • FastAPI backend
  • Git repository processing
  • Nginx
Nginx serves the frontend and reverse-proxies API requests to the FastAPI backend.

Amazon RDS

We use Amazon RDS for PostgreSQL as our managed database.
Repository metadata generated during Git ingestion is stored in RDS, while the cloned Git repositories remain on EC2 for historical Git operations.

Production Architecture

User → EC2 → Nginx → React Frontend
           ↓
         FastAPI Backend
        ↙     ↘
     Git Repository  Amazon RDS
Using EC2 and RDS gave us hands-on experience with cloud deployment, server configuration, networking, security groups, environment variables, database connectivity, and production application architecture.

What Fought Back

The hardest part of GitWiz was not creating an individual page or API. It was dealing with the complexity of real Git history and then making that information useful to a human.

Non-linear Git History

Git is not simply a chronological list. Branches can diverge, commits can have multiple parents, and merges create complex relationships.
Representing this correctly required careful processing of commit-parent relationships before the information could be turned into a visual graph.

Raw Git Processing

Rather than depending entirely on a Git abstraction library, our backend communicates with Git through Python's  subprocess  module.
This meant handling command execution, repository paths, errors, timeouts, and repositories with different structures and sizes.

Making Data Visual

Extracting thousands of pieces of historical information is one challenge. Making that information understandable without overwhelming the user is another.
We had to connect backend data with interactive visual components so users could move from a repository overview → a specific branch → a specific commit → the exact code changes behind it.

Cloud Deployment

Moving the application from localhost to AWS introduced another layer of complexity.
We had to configure EC2, Nginx, security groups, environment variables, and RDS connectivity while ensuring that the frontend, backend, Git repositories, and database worked together in production.

Why GitWiz?

Git history is usually treated as a record of what happened.
GitWiz treats it as data that can be explored.
The same history that appears as hundreds or thousands of commits in a traditional interface can become a visual map of:
Who contributed → when development happened → how branches evolved → which commits changed the project → how the actual code changed.
This makes GitWiz useful for:
  • Developer onboarding: understand an unfamiliar codebase faster
  • Debugging & maintenance: trace when and where changes were introduced
  • Feature evolution: follow how a feature developed across commits
  • Code archaeology: investigate historical decisions and changes
  • Education: visually learn how real software projects evolve

Learning & Growth

Building GitWiz pushed us beyond simply building a frontend or backend.
We gained practical experience with Git internals, repository processing, REST APIs, database design, asynchronous backend operations, interactive data visualization, Nginx, Linux server administration, and AWS deployment.
Most importantly, we experienced the complete journey from:
Idea → Architecture → Development → Integration → Cloud Deployment
GitWiz is our attempt to make one of the most valuable but underused sources of information in software development, Git history, easier to see, understand, and explore.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article