Building Fiesta Agency: Because Apparently, “Just Make It Look Good” Wasn’t Enough

Arum — Wed, 16 Sep 2026 21:24:14 +0000

One of the projects I’ve been working on recently is Fiesta Agency, an event planning and entertainment agency based in Kigali, Rwanda.

The goal was to build a modern website that reflects the energy of the brand, showcases their services and events, and gives potential clients a proper place to explore what they do.

Simple enough.

Then, as usual with development, “simple” started growing features. 😅

I wanted the website to feel visual and interactive without making it difficult to use.

The stack:

React • TypeScript • Vite
Tailwind CSS • shadcn/ui
Framer Motion • Supabase
React Router

The platform includes services, events, portfolio, company information, how Fiesta works, and contact.

But making the frontend look good was only part of the job.

Because apparently, websites are also expected to actually work.

I built a content management system backed by Supabase so events, portfolio items, and media can be managed without opening the code every time something needs to change.

That part was particularly interesting because it pushed me to think beyond the interface and consider how the website would actually be maintained and used after launch.

I also made sure the experience works across different screen sizes, because a beautiful desktop website that falls apart on a phone is basically just expensive wallpaper.

Building Fiesta gave me the chance to work across different parts of a web application, from the UI and frontend architecture to backend data and content management.

The website is now live.

Live Website: https://fiesta-agency-done.vercel.app/

You can check out the live version a

Another build shipped.
On to the next one.

dev contest: Telecom RCA Automation System

Arum — Sun, 12 Jul 2026 21:20:59 +0000

This is a submission for [Weekend Challenge: Passion Edition]
What I Built

Over the years, I watched my mom do the same work over and over, often spending 2 to 4 hours preparing a single telecom SLA report. She works in network field maintenance for a telecom company in Nigeria, and every reporting cycle she has to manually read fault descriptions from field engineers, usually pasted directly from WhatsApp, classify each fault into the company's standardized taxonomy, and format everything into an Excel compliance report.

At one point, I learned the process myself so I could truly understand what she was going through. After doing it firsthand, I realized how mentally and physically exhausting it was. Sitting for hours on a repetitive task that required constant attention wasn't just inefficient, it was draining.

That experience made me ask one simple question:

What could I build to make this easier for her?

That question became this project.

The Telecom RCA Automation System reduces a task that used to take 2 to 4 hours to about 5 minutes, cutting the workload by more than 95% while improving consistency and reducing manual errors.

More than anything else, this project is about giving someone I love a few hours of her evening back.

Demo

https://telecom-rca-automation-system.vercel.app
*🎥 Demo Walkthrough *

https://youtu.be/EIdFDKtcIZw

The video demonstrates the complete workflow, from uploading the telecom availability report to generating the final SLA report, and highlights how Google Gemini AI assists with ambiguous fault classification.

Code

https://github.com/tony123117/Telecom-RCA-Automation-System.git

How I Built It

The application is a 6-step workflow built with React 19, TanStack Start, TypeScript, and Tailwind CSS v4, with Supabase (Postgres + Row Level Security) providing persistence and continuous learning.

Upload

Upload the raw Huawei RNATracker availability export (.xlsb).

Configure

Select the report date, network, states, and availability threshold.

Preview

Review the filtered list of affected sites before processing begins.

Classify

Paste the raw WhatsApp fault descriptions from field engineers.

Each fault passes through an 8-stage classification pipeline in priority order:

Short-duration rules
Hard overrides
Learned corrections
Partner-aware keyword engine
Google Gemini AI
Partner lock
Site history fallback
Generic fuzzy fallback

Review

Inspect and edit classifications with inline editing and keyboard shortcuts.

Export

Generate a professionally formatted Excel SLA report with:

Color-coded rows
Auto-filters
Summary statistics

The exported report is ready for submission with little or no manual editing.

The Most Challenging Part: Building the Parser

One of the hardest parts of the project was building a parser capable of understanding the messy WhatsApp messages sent by field engineers.

These reports are rarely consistent.

They often contain:

Glued site IDs with no separators
Missing leading zeros
Nested site groups
Cascade faults
Multiple duration formats

For example:

EN0035+25(EN0707,EN0377):
DG fail to start =34mins

1hr 20mins

1:20hrs

The parser automatically extracts:

Site IDs
Cascade faults
Fault descriptions
Outage durations

without requiring users to clean or reformat the text first.

Whenever the parser cannot confidently understand a report, it sends only that fault description to Google Gemini through a secure server-side proxy, ensuring the API key never reaches the client.

Partner-Aware Classification

One interesting challenge is that the same fault description doesn't always belong to the same RCA category.

For example, a fault like "DG fail to start" may belong to different SLA categories depending on whether the affected site is managed by IHS, ATC, or another infrastructure partner.

Because of this, the classifier is partner-aware first and keyword-based second, allowing it to produce more accurate classifications.

Continuous Learning

The system also improves over time.

Whenever my mom corrects a classification during the review step, that correction is stored in Supabase as a learned mapping.

The next time a similar fault appears, the application automatically applies the corrected classification without requiring any separate training process.

Instead of asking users to teach the model, the application quietly learns through normal day-to-day use.

Why I Used Google Gemini

I'm submitting this project for Best Use of Google AI.

Most faults are classified using deterministic rules, making the application extremely fast.

Only ambiguous or previously unseen fault descriptions are sent to Gemini 2.0 Flash, where it performs structured extraction and intelligent classification.

To keep the system efficient and affordable, requests are:

Cached for 7 days
Batched into chunks
Only sent when local rules cannot confidently classify the fault

This approach combines the speed of rule-based systems with the flexibility of modern AI.

Impact

The Telecom RCA Automation System transforms a repetitive, error-prone reporting process into a workflow that takes about 5 minutes instead of 2 to 4 hours.

It combines intelligent parsing, rule-based automation, continuous learning, and Google Gemini AI to automate telecom RCA and SLA report generation.

More importantly, it solves a real problem for someone who inspired me to build it in the first place.

Prize Category

Best Use of Google AI

Google Gemini 2.0 Flash powers the intelligent classification of fault descriptions that fall outside local deterministic rules, providing accurate structured extraction while remaining fast and cost-effective through caching and request batching.

Team

DEV Username: @tony_dev

I am the sole developer on this project. I handled the design, development, classification logic, AI integration, database architecture, testing, and deployment.

PASSWORD: 4cCyU6D***
email: arum200909@gmail.com

DEV Community: Arum

Building Fiesta Agency: Because Apparently, “Just Make It Look Good” Wasn’t Enough

dev contest: Telecom RCA Automation System