This is a submission for the GitHub Finish-Up-A-Thon Challenge

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Over the past few weeks, I built observe., an observability platform designed to help developers understand what is happening inside their applications. I built it because myself and some other Nigerian developers couldn't keep up with the cost of enterprise tools.

The platform combines several capabilities that are often spread across multiple tools:

• Product analytics
• Uptime monitoring
• Error tracking
• API monitoring

The goal was simple: provide a single dashboard where developers can answer questions like:

Are users actually using my product?
Which features are being used?
Is my application online?
Are there increasing error rates?
Are API endpoints slowing down?

The project is built with:

• FastAPI
• PostgreSQL
• Redis
• Celery
• React
• TypeScript

What started as an exploration of analytics systems eventually grew into a complete end-to-end product with event ingestion, monitoring services, background workers, dashboards and project management.

Demo

Live Project

Observe.

Source Code
Backend: https://github.com/Im-Kaycee/Observability-backend
Frontend: https://github.com/Im-Kaycee/observability-dashboard

Screenshots

Video Walkthrough

The Comeback Story

This project started as a much smaller analytics experiment.

Initially, the focus was simply recording events from applications and displaying them in a dashboard.

As development continued, I realized that analytics alone only tells part of the story.

Knowing what users are doing is useful, but it doesn't tell you:

When your application is down
Whether APIs are healthy
If users are encountering errors

So I expanded the project into a broader observability platform.

Some of the major additions included:

1. Event Ingestion Pipeline

I built a system that accepts events from client applications and stores them for analysis.

This required designing concepts such as:

• Projects
• API keys
• Visitors
• Users
• Events

and understanding how modern analytics platforms associate anonymous activity with identified users.

2.Monitoring Services

I added uptime monitoring and API monitoring so developers can track application health alongside user behavior.

Background Processing

Using Celery and Redis, I introduced background workers for tasks that shouldn't run inside request-response cycles.

1. Dashboard Experience

One of the biggest improvements was the frontend.

I redesigned the interface around a clean, serious aesthetic with subtle neobrutalist accents to make large amounts of monitoring data easier to navigate.

By the end of the challenge, the project had evolved from a partially completed analytics idea into a fully functional observability platform.

My Experience with GitHub Copilot

GitHub Copilot helped accelerate development throughout the project.

Some of the areas where it was most useful included:

1. Boilerplate Generation

Copilot was particularly effective at generating repetitive code such as:

CRUD endpoints
Database models
Schema definitions
Validation logic
Refactoring

As the architecture evolved, Copilot helped quickly update code paths and maintain consistency across files.

1. Frontend Development

Building dashboards often involves repetitive UI patterns. Copilot significantly reduced the time required to create and iterate on components.

1. Learning and Exploration

One of the most valuable aspects was using Copilot as a development companion while working through unfamiliar implementation details and architectural decisions.

Rather than replacing problem solving, it allowed me to spend more time thinking about system design and product decisions instead of writing repetitive code.

Built by

Kelechukwu Favour(https://dev.to/nulfacedesigner)

GitHub: https://github.com/im-kaycee