DEV Community: Eliezer Jose Polidor Solano

ArbNet Bug Smash: Fixing Cloud Expiration & Database Connection Failures with Sentry & Google AI

Eliezer Jose Polidor Solano — Tue, 18 Aug 2026 04:46:08 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

ArbNet is an automated crypto arbitrage application designed to track P2P trading opportunities across exchange platforms like Binance. The stack consists of an ASP.NET Core (.NET 8) Web API backend paired with a React (Vite) frontend and a PostgreSQL database.

Bug Fix or Performance Improvement

Bug Description During the transition of the ArbNet project to a local development environment, the system became completely inoperable due to the expiration of the trial subscription on Railway, which triggered a two-level failure:

Backend (.NET 8): API requests failed with a System.InvalidOperationException due to lost connectivity with the cloud-hosted PostgreSQL database (transient failure).
Frontend (React): HTTP requests originating from the authentication component (Welcome.jsx) attempted to reach the inactive Railway URL (arbnet-production.up.railway.app), resulting in an immediate network error (TypeError: Failed to fetch).

Sentry Telemetry & Capture Thanks to the Sentry SDK integrated across both Backend and Frontend, the following real-time events were captured:

🔹 Backend Event (.NET)
Issue ID: DOTNET-ASPNETCORE-3 (Event ID: 8da4123b)
Exception: System.InvalidOperationException
Message: "An exception has been raised that is likely due to a transient failure."
State: Unhandled
Exact Location: Controllers\UsersController.cs inside asynchronous task Task>
Affected Endpoint: /api/Users/register
🔹 Frontend Event (React)
Issue ID / Message: TypeError: Failed to fetch (arbnet-production.up.railway.app)
User Action (Breadcrumb): Click on button.btn-register-submit
→
Request POST https://arbnet-production.up.railway.app/api/users/register
🔹 Environment
Runtime: .NET 8.0.29 & React (Vite)
OS: Windows 11
Environment: development
Release: 1.0.0 (a6cd6355e101)
Frontend Error Evidence (Sentry)

Direct Link in Sentry:
View Issue ARBNETFRONTEND-1 on Sentry

Backend Error Evidence (Sentry)

Direct Link in Sentry:
View Issue ARBNETBACKEND on Sentry

Diagnosis & Fix 🔍 Diagnosis with Google AI / Sentry Insights By analyzing network traces, Breadcrumbs, and exception logs captured by Sentry:

Confirmed the remote PostgreSQL database lockup caused by cloud provider trial expiration.
Detected that fetch requests in Welcome.jsx were still targeting the obsolete Railway production URL, interrupting both registration and login flows.
🛠️ Applied Fix (Step by Step)

Local Database Migration and Setup PostgreSQL was installed locally, the ArbNet database schema was created, and the connection string in the backend's appsettings.json was updated:

"ConnectionStrings": {
"DefaultConnection": "Host=localhost; Database=ArbNet; Username=postgres; Password=your_password"

}

2. Reconfiguring Fetch in Frontend (React)

Re-routed the React client to the local server by updating the environment variable in .env.local:

VITE_API_URL=https://localhost:7039
const response = await fetch(${import.meta.env.VITE_API_URL}/api/users/register, { ... });

CORS Policy Configuration in .NET builder.Services.AddCors(options => { options.AddPolicy("AllowLocalhost", policy => { policy.WithOrigins("http://localhost:5173", "http://localhost:3000") .AllowAnyHeader() .AllowAnyMethod(); }); }); app.UseCors("AllowLocalhost"); 📌 Version Control All updates and bug fixes were integrated and pushed to the branch: bugfix --- ## Code All code changes, database migrations, and CORS reconfigurations have been merged and submitted via Pull Request to the project repository.

Repository Branch: bugfix

* Pull Request: View Pull Request #1 on GitHub

My Improvements

To restore ArbNet's operational status without breaking project maintainability, I took a systematic, telemetry-driven approach powered by Sentry Insights and Google AI (Gemini):

Key Technical Decisions:

Root Cause Analysis via Telemetry & AI:
- Instead of manual log hunting, I analyzed Sentry breadcrumbs and stack traces alongside Google AI to pinpoint the exact failure points: the expired PostgreSQL instance on Railway and the hardcoded production API endpoint in React.
Full-Stack Local Migration:
- Database: Provisioned a local PostgreSQL instance and restored the complete ArbNet schema, updating the connection string in ASP.NET Core (appsettings.json).
- Environment Variable Decoupling: Replaced hardcoded fetch URLs in React with Vite's import.meta.env.VITE_API_URL pointing to localhost:7039, ensuring clean separation between local development and production configs.
Secure Cross-Origin Policy:

* Configured explicit CORS rules in .NET 8 (Program.cs) allowing local development origins (localhost:5173 and localhost:3000) while restricting unauthorized origins.

Best Use of Sentry

Yes, this project relies heavily on Sentry Error Monitoring and Breadcrumb Tracing across both the frontend (React) and backend (.NET 8):

Full-Stack Error Monitoring: Configured Sentry SDKs on both client and server sides to capture unhandled exceptions during API route requests (/api/users/register).
Breadcrumb Analysis: Used Sentry's event breadcrumbs to trace the sequence of user actions—specifically capturing the submit event on button.btn-register-submit up to the failed network request against the expired Railway host.

* Stack Trace Insights: Analyzed full backend stack traces (identifying `System.InvalidOperationException` in `UsersController.cs`) to differentiate between network-level CORS issues and database connection failure.

Best Use of Google AI

Yes! Google AI (Gemini) served as a core AI debugging collaborator during the resolution of this issue:

Sentry Log Analysis: Leveraged Google AI to analyze complex Sentry stack traces (System.InvalidOperationException and CORS preflight failures), quickly isolating the root cause between cloud provider expiration and frontend endpoint misconfiguration.
Architecture & Migration Design: Used Google AI to structure the local database migration workflow, update .env.local variable decoupling in React (Vite), and implement robust CORS policy definitions in ASP.NET Core (.NET 8).
Documentation & Telemetry Integration: Assisted in formatting clear telemetry reports and structuring the Pull Request documentation to align with industry best practices.

FutboLeyendas - El Olimpo del Fútbol con Gemini AI

Eliezer Jose Polidor Solano — Mon, 13 Jul 2026 05:27:39 +0000

FootLegends⚽🤖

Our Passion Project

Football is pure passion. The debate over who is the true GOAT (Greatest of All Time) drives endless, heated discussions in every corner of the world. FutboLeyendas transforms this emotional debate into a live interactive experience where statistical data and historical glory face the neutral judgment of Artificial Intelligence.

What I Built

I built a web application using React and Vite that allows football fans to configure dynamic sliders based on what they value most in a player: Scoring Power, World Cups, Fast Play / Discipline, or Effectiveness Under Pressure. The platform features 21 football legends, crosses their real historical stats with the user's custom weights, and feeds this structured context to Google AI (Gemini) to deliver an objective, deeply detailed final verdict on who wins the ultimate duel.

Key Features

Real-Time Attribute Tweaking: Dynamic range sliders that instantly recalculate the weight of each metric.
Smart AI Verdict: Direct integration with Google's Gemini model to act as an unbiased, expert sports judge.
Modern & Fluid UI: A dark-themed, responsive, and highly aesthetic interface built for an immersive experience.

🚀 Experience the GOAT Debate Live!

The wait is over! FutboLeyendas is officially live in production. You can now test your ultimate football matchups, adjust real-time player attributes, and let Google Gemini’s artificial intelligence deliver the definitive verdict on who truly dominates the football Olympus. Give it a spin, challenge the stats, and see who comes out on top here: 👉 futbo-leyendas.vercel.app ⚽🤖

Link to Code

You can check out the full repository, detailed architecture, and screenshots here:
👉 https://github.com/eliezerpolidor/FutboLeyendas

Reviving ArbNet: The Automated P2P Arbitrage Tracker I Built for My Son (and How I Defied Regional Blocks)

Eliezer Jose Polidor Solano — Mon, 08 Jun 2026 04:01:41 +0000

Live Production Application

The ArbNet application is fully deployed and ready for testing!
You can access the live environment, interact with the user interface, and review the working integration between the React frontend and the .NET Core backend here:
🔗 https://empowering-gentleness-production-33bc.up.railway.app/
🔐 Demo Credentials for Testing:
Email: user@arbnet.com
Password: 123456
This is a submission for the GitHub Finish-Up-A-Thon Challenge
It all started with a very close and real family need. My son and I recently entered the cryptocurrency and P2P arbitrage market on platforms like Binance. One day, he told me he was losing a massive amount of time manually recording every single operation and that he frequently made errors when typing his buys and sells into an Excel spreadsheet. Those discrepancies and human errors were creating real headaches for managing his finances.

As a developer, I took it upon myself to help him. That’s how the idea for ArbNet was born: an automated platform designed to monitor arbitrage spreads in real time, connecting a robust .NET 8 (C#) backend with an agile React frontend, completely eliminating conventional spreadsheets.

I want to highlight that what I am presenting today for this challenge is a fully functional Demo version (Proof of Concept) that simulates and structures the main core flows of the system. However, this is only the first step. I plan to fully develop the ArbNet application, strengthen its API integrations, and launch the entire ecosystem into the market as an official SaaS solution to optimize operations for thousands of P2P arbitrage traders.

Demo

Our complete code ecosystem, setup scripts, and visual documentation can be found here:

GitHub Repository: https://github.com/eliezerpolidor/ArbNet.git
Te invito a conocer el proyecto viendo este video en youtube: 🔗 Demo de ArbNet en video: [https://youtu.be/hGiBRZr5xEs]

Pantalla Principal del Programa Arbnet
Arquitectura de la Base de Datos ArbNet Modelo Entidad-Relación.
Diagrama Asincrónico

The Comeback Story

Developing this project under pressure and against the clock left the local repository in absolute chaos just hours before the challenge deadline: duplicated UI screenshots, local cache files (.vs) leaking into Git, and a README.md file with a completely illegible directory tree. The project was stuck in limbo.

For this challenge, I set out to completely clean the repository and elevate ArbNet to a professional production standard. I forced Git to drop ghost traces of temporary files using advanced terminal commands, parameterized a strict .gitignore to protect private credentials, centralized the SQL Server script (arbnet_setup.sql) to make it portable, and redesigned the README.md documentation by integrating a clean folder structure mapped line-by-line (├──).

Finishing a project isn’t just about making it compile; it’s about delivering clean code that solves a real-world problem for the community to adopt.

My Experience with GitHub Copilot

To achieve this final sprint in record time, my initial plan was to rely heavily on GitHub Copilot. However, as many developers know, this AI is not available in my region due to geographic blocking in Venezuela. This is where the challenge doubled, and I had to get creative.

Bypassing the Block: To use Copilot, I had to use a VPN, specifically TunnelBear. I managed to bypass the restriction several times, but the system runs strict and permanent checks. There were moments when the block became unbreakable, forcing me to temporarily turn to Gemini and Blackbox to keep the momentum going. Even so, I managed to do most of the heavy lifting with Copilot.
Vital Advice for the DEV Community (Performance & Security Tip): Fellow developers, if you are going to use a VPN to test restricted tools, do not use browser extensions. The algorithms detect them almost instantly. It is much better to activate the VPN at the OS level (from the outside).
The Performance Trick: Having SQL Server, Visual Studio, Visual Studio Code open, and a VPN running in the background simultaneously slows down your machine significantly. The strategy I applied and highly recommend is: activate the VPN only at the exact moment you need to consult or generate something with Copilot, and once you start your hard coding work, close Copilot and deactivate the VPN. This kept my development environment running smoothly.

It would be awesome if these types of geographic blocks were removed, as it would save developers a lot of time and effort spent dodging restrictions instead of just coding. But in the end, we made it happen! The AI helped me structure complex Git commands to resolve TortoiseGit conflicts and format the Markdown documentation tree in seconds.

Thank you so much to GitHub and the DEV Community for this challenge that pushes us to break through borders and technical barriers to reach the finish line!