Solana Green Dashboard — Visualizing Blockchain's Greenest Network

Archit Jagadeb — Sat, 18 Apr 2026 15:37:38 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

The Solana Green Dashboard is a data visualization web app that tells the environmental
story of the Solana blockchain. Instead of just showing numbers, it presents Solana's
energy efficiency as a visual narrative — comparing it against Ethereum and Bitcoin in
a way that's easy to understand for anyone, not just crypto people.

The dashboard pulls live transaction data directly from the Solana mainnet and displays
it alongside static environmental benchmarks sourced from the Solana Foundation and the
Cambridge Bitcoin Electricity Consumption Index. The goal was simple: show that not all
blockchains are created equal when it comes to their impact on the planet.

It covers four key areas. First, live network performance showing real transactions per
second updating every 10 seconds. Second, energy consumption comparing how much power
each blockchain uses per transaction. Third, carbon footprint showing CO₂ emissions
across Solana, Ethereum and Bitcoin. Fourth, a CO₂ saved counter showing the estimated
carbon saved per million transactions compared to Bitcoin.

Demo

🌍 Live Site: https://solana-green-dashboard.onrender.com

Code

architjagadeb / solana-green-dashboard

How I Built It

The entire project is built with pure HTML, CSS and vanilla JavaScript — no frameworks,
no build tools, no npm. Just files you can open directly in a browser.

The frontend uses Playfair Display for headings to give it an editorial magazine feel,
mixed with Inter for body text. The layout is a single scrollable page where charts and
text alternate section by section, rather than cramming everything into one grid. The
color palette is warm — beige, brown and forest green — intentionally chosen to feel
earthy and grounded.

For the Solana integration, I used the Helius RPC endpoint to call
getRecentPerformanceSamples via a standard JSON-RPC POST request. This returns the last
10 performance samples from the Solana mainnet. Each sample contains numTransactions and
samplePeriodSecs, so TPS is calculated as numTransactions divided by samplePeriodSecs.
The chart refreshes every 10 seconds with the latest data. If the RPC call ever fails,
the dashboard falls back to realistic mock data so the page never breaks.

Charts are powered by Chart.js loaded via CDN. The energy comparison uses a logarithmic
scale because the difference between Solana and Bitcoin is so large that a normal scale
would make Solana's bar invisible. That design decision alone tells the environmental
story better than any paragraph could.

One interesting challenge was CORS. The default public Solana RPC endpoint blocks browser
fetch requests, so I had to switch to Helius which supports browser-based calls. This is
something worth knowing if you are building any frontend Solana app.

The scroll animations use the Intersection Observer API — sections fade in as you scroll
down, which makes the page feel like you are reading through a story rather than landing
on a static dashboard.

Prize Categories

Best Use of Solana — The project uses the Solana mainnet RPC to fetch live network
performance data directly in the browser using vanilla JavaScript. The getRecentPerformanceSamples
method is called every 10 seconds and the results are parsed and visualized in a live
updating line chart, making Solana data the core of the entire dashboard experience.

a bot which emails me daily

Archit Jagadeb — Tue, 31 Mar 2026 05:08:15 +0000

Real learning comes from building, not just watching tutorials.

I recently completed Anthropic's two courses:

Introduction to ModelContextProtocol [link]
ModelContextProtocol: Advanced Topics [link]

After completing this course, I wanted to build something of my own, which would help me in my daily life chores.

Why this project ?

Honestly? I am a lazy fellow and terrible at time management.But lately I have been realizing how indispensable discipline is in life. So I thought why not to make something which autonomously manages my day without me lifting a finger.

Every morning it dispatches a single comprehensive email covering:

📰 Top news from my favourite sources
📅 Calendar summary with personalized meal and gym suggestions
💪 Health analysis based on sleep, water intake and steps
💰 Finance insights based on daily expenses

All powered by Groq API. Completely free. Running locally on my Mac.

My Background

I am 19, currently in my first year of BTech CSE and have been coding since last 9 months.

Nine Months. That's it.

Before this project, I had worked extensively with Python's data science ecosystem and built a personal finance tracking application called ArthaX. But I wanted more. I wanted to learn deep about the AI systems, and I think learning about MCPs is one the very first step in my AI career.

Tech Stacks

Python
Groq API
Gmail via SMTP
MCP Python SDK
FastMCP

The Obstacles

Model Confusion ->
gemini-1.5-flash was deprecated, gemini-2.0-flash had zero quota in India, gemini-2.5-flash had a 20 request/day limitation. Eventually switched to Groq API which is completely free with no such restrictions.
API Rate Limits ->
I was testing so aggressively that I kept exhausting my quota mid-build. Had to exercise patience and return after the limits reset.
Combining Everything ->
The most formidable challenge was email_handler.py — orchestrating all modules simultaneously, resolving indentation errors, handling Unicode encoding failures in email, and ensuring prompts were correctly passed to the model.
MCP Server Working Directory —>
Claude Desktop launches the MCP server from a different directory, so all file paths had to be converted to absolute paths. A small but frustrating bug to track down!

What I Learned

- Python vs C++
The syntax is different but the logic is the same. Coming from C++, I was surprised how simple Python functions and loops are — no brackets, no semicolons, just clean readable code.

- AI APIs
Gemini helped me understand how to interact with AI models during the build process, while Groq became my execution engine for the final product. Both taught me how to craft prompts that actually work.

- MCP in practice
The course taught me the theory, but building my own MCP server taught me how servers actually work — how tools are exposed, how clients connect, and how Claude Desktop integrates with your own code in real time.

- Automation
I had never set up a cron job before. Learning to schedule Python scripts at 7am and 9pm felt like giving my project a heartbeat.

- Never share your API key
I accidentally pasted my live Gemini API key in a chat. Revoked it within seconds but learned the hard way — always use .env files and never share secrets publicly.

[Github]
[LinkedIn]

Forem: Archit Jagadeb