DEV Community: Giovanni Zanotti

Fighting Decision Fatigue: How ClimbStack was Born

Giovanni Zanotti — Thu, 29 Oct 2026 13:00:00 +0000

TL;DR:

What: A React Native Open Source productivity App.

Tech: React Native, SQLite, Typescript, i18n, CI/CD

Results: Free Open Source app available on Play Store

Read further to: discover how I transformed my problem into an actual application

The Problem

Too often, I’d find myself paralyzed by decision fatigue, mindlessly scrolling on my phone instead of doing something that actually helped me grow or learn something new. I’ve always loved productivity apps with sleek planners and cool UI, but I could never find one that had exactly the tools I needed without being locked behind a subscription paywall.

The Idea

That's when I realized it was time to stop searching and start building. I wanted to engineer my own solution—something that could genuinely help me, and hopefully others, overcome this exact problem.

I’ve always loved the concept of "gamifying" daily routines (completing tasks and gaining something in return) and I am a huge fan of mountain trekking. That’s how I decided to shape the core identity of my app: combining gamification with a trekking analogy. The goal is to help users "climb" their days, conquer their decision fatigue, and ultimately reach their peaks.

ClimbStack

And that's how ClimbStack was born. The application is built around five main basecamps:

Today: A minimalist interface to check your daily tasks at a glance, eliminating the time spent thinking about what to do next.
Peaks: The place to track your main goals. You can divide them into smaller "sub-camps," making it easier to climb towards your objectives. Here you can also check your current altitude, the total number of peaks reached, and your daily streak.
Planner: A drag-and-drop environment where you take your customized "Blocks" (see below) and place them into your week. It synchronizes in real-time with your local calendar, allowing you to view your ClimbStack tasks and personal events in one unified space.
Blocks: Where creativity takes place. You can create personalized categories and blocks for the planner without any limits. By assigning a weekly hourly target, it becomes much easier to reach your quota while organizing your schedule.
Settings: The control room to personalize your experience. You can switch between multiple languages (EN | IT | DE | ES | FR) and manage your local backups to seamlessly switch devices or store your data safely.

Privacy First, Always Offline

As a developer, my main goal was to keep all your data strictly private. ClimbStack is designed to be 100% offline-first, meaning you can use it wherever you are: at school, on the subway, or literally at the peak of a mountain.

To achieve this, the app relies on a local SQLite database. As mentioned, it synchronizes exclusively with your device's local calendar, bypassing invasive cloud integrations. Even the backup system is designed around a local JSON file, giving the user total sovereignty over whether to store their data locally or upload it to their cloud of choice.

Open-Source and Production

The application has been developed—and will continuously evolve—in a fully open-source ecosystem. All the code is publicly available on GitHub: ClimbStack's Repo.

The repository is structured to welcome anyone. You can participate by opening an issue, proposing a new feature, or getting your hands dirty with the code and submitting a PR! Everyone is welcome to share their ideas and help build the ultimate productivity tool.

Now It's Your Turn

The app is officially available on the Google Play Store, and you can start climbing today. Feel free to contribute on GitHub (a star ⭐ is always appreciated!) or follow the project's updates on our LinkedIn Page.

While an iOS release isn't immediately on the horizon, sponsoring or contributing to the project is the best way to help us bring ClimbStack to the Apple ecosystem soon!

Now pack your gear, download the app, and start climbing!

About the Author

Hi, I’m GiZano! I am a BSc Computer Science student at the University of Pisa, deeply passionate about IoT, local AI, and sustainable technology. As an active Open Source contributor, my goal is to dive deeper into the FOSS (Free and Open-Source Software) world and help make tech accessible to everyone.

Let's connect! LinkedIn | GitHub | Personal Website

Winning a Tech Contest with bE-More: Integrating IoT and Local AI for a Greener Office

Giovanni Zanotti — Thu, 24 Sep 2026 11:00:00 +0000

TL;DR:
What: An IoT semi-automatic system for company energy saving.
Tech: Java 23, Arduino, MQTT, ThingsBoard and local AI (Ollama/Mistral:7b).
Results: Winner of school contest 'Project Day' 2025.
Read further to: discover how local AI can analyze IoT data respecting privacy and environment.

I. The Background

My journey with bE-More started in february 2025, when my team started to gear up for the Project Day, the most anticipated event in my school.

Every year this contest transforms the school in a tech hub, where teams from all classes gather to showcase their projects to representatives of companies of our territory.
We didn't want to develop a project like others, we wanted to create a professional solution for an actual global problem: energy saving.

II. The Inspo

To be sure we developed a project that would be in demand, we knew we had to resolve a real-world problem. That's how we decided to look at Agenda 2030, which challenges companies to comply with stricter environmental standards and enhance their energy savings.
However, we found a significant friction point: while trying to optimize, companies are deeply concerned about data privacy. Sending sensitive telemetries to the cloud for analysis can often become a deal-breaker.

This is why we decided to rely on a local AI analysis system. By using Ollama and the (then) newborn Mistral:7b, we created a light-weight, fast and secure solution. It allows users to get data insights and detect anomalies without spending hours reading long, complex charts.

III. The Project Architecture

III.I The Tech Stack

Our solution relies on different components talking to each other to gather, store and analyze data for the end user, who can then make decisions based on AI-driven insights.
The Controller (Java 23): A desktop app which works as central hub, using WebView for the dashboard and manages the life cycle of AI analysis processes.

The IoT Hub (ThingsBoard): We selected platform for robust data handling and storing, using MQTT and real-time dashboards on the port 8080.

The Edge Hardware (Arduino): The actual operator of the system. It is responsible for gathering real-time telemetry from light sensors and executing local automation rules to save energy.

The Intelligence (Python & Ollama): A middleware service that acts as a bridge between the data and the AI model by querying the PostgreSQL database of ThingsBoard to feed the Mistral:7b model.

III.II The Communication

To be able to communicate, the components used MQTT and HTTP(s) protocols, which make the architecture fast and secure.

MQTT (Message Queuing Telemetry Transport): a light-weight transport protocol to exchange messages based on the subdivision of devices in publishers and subscribers, relying on a central broker that rules the exchange of telemetries in channels called topics. In our project, it's the heartbeat of the communication between the Arduino and ThingsBoard.
HTTP (HyperText Transport Protocol): a request/response protocol, relying on different types of calls (i.e. GET, POST, PUT). We used it to serve the web-based dashboards from the server to the Java app. While HTTP is natively insecure, it is possible to implement HTTPS to encrypt data between the server and the end-user, ensuring that corporate sensitive data remains protected from interceptions.

IV. The Diorama: Bringing Code to Life

To demonstrate bE-More during the showcase, we didn't just show a screen with code, we built a physical prototype. This diorama represents a typical office environment where our architecture could be tested in real-time.

IV.I The Physical Implementation

The diorama was designed to be a miniature office. We integrated the sensor and actuators directly into the structure to simulate a real-life installation:

The Main Workspace LEDs: Representing the lighting system, controlled by the Arduino.
Status Feedback: A dedicated LED is used to indicate if the automatic mode is activated, while a Buzzer is used to signal acoustically when the mode is switched.
Interactive Controls: Two physical buttons were placed on the Arduino Shell to allow the user to toggle between manual control and Autonomous Mode.

IV.II Circuitery in the Crafted Arduino Shell

The central point of the diorama is an Arduino microcontroller (Arduino UNO R4, to natively host Wi-Fi functionalities) that runs a deterministic logic to ensure energy saving without human intervention.

The automation follows a simple rule:

Sensor Input: a photoresistor (connected to pin A3) continuously monitors the environments natural light.
The Publishing: the Arduino automatically logins (registering can be both manual and automatic on the platoform) to the ThingsBoard MQTT broker, which stores data in the database of the platform.
The Threshold: if the 'AUTO' mode is active and the natural light value exceeds a value of 450, the system automatically powers down the lighting system.

V. Conclusion: The Victory

Thanks to the project and development process, where we found great synergies between the selected technologies, we developed a working product that could be installed in a real-life scenario.

The Project Day 2025 was an unforgettable experience, where the interest of the company representatives was the ultimate validation of our hard work. We were honored to be announced as winners, a title we shared with another brilliant project from our class (VIPRA, whose github repo can be found here).

This double victory proved that our school is a real nursery for innovation, where sustainability and technology meet to solve actual problems.

VI. Extra: Future Possible Developments

1. Security (HTTPS)

While the initial web server used HTTP, a professional migration to HTTPS would be the next priority. By adding an SSL/TLS layer, we can encrypt all data between the server and the end-user, ensuring total privacy during delivery.

2. Artificial Intelligence

The local AI landscape has exploded since we first started. We could now enhance our analysis through:
↳ Prompt Engineering: refining the input prompts to make more accurate insights from telemetry.
↳ Llama 3: swapping to a more modern model to use better reasoning capabilities while keeping the same infrastructure.
↳ Ad Hoc AI Models: creating a custom-trained model based on specific analysis samples, allowing a fine-tuned weight balancing.

3. Actuators

Decoupled Architecture: in the diorama, one Arduino handled both the sensor and actuator roles. In a real-life deployment, these would appear in separate devices distributed across different zones.
ESP32 Board: for a final product, we would switch to ESP32 board, which include native Wi-Fi, smaller size and superior processing power.

4. Advanced MQTT Infrastructure

Currently, our implementation uses an unilateral MQTT flow for telemetry. Introducing an intermediary broker, such as Mosquitto, we would enable bi-directional communication, allowing for real-time analysis and immediate automated correction through actuators without the need to risk database integrity and injections.

VII. Bibliography and Project Links

VII.I The Project

GitHub (code)

VII.II Bibliography

ThingsBoard
Arduino
MQTT
HTTP
Ollama
Mistral:7b

About the Author

GiZano: I am a BSc in CS at University of Pisa with a deep passion for IoT, local AI, and sustainable tech. As the lead architect of bE-More, I focus on building systems that bridge the gap between complex software and real-world environmental impact - always with a privacy-first mindset.

Beyond winning the Project Day 2025, I'm constantly exploring new ways to integrate modern stacks like Java 23, Python aiohttp and local LLMs into everyday life,

Let's connect!
Linkedin
GitHub
Personal website

This article was originally published on my Medium blog

Why High School is the Perfect Time to Start Contributing to Open Source

Giovanni Zanotti — Tue, 22 Sep 2026 11:00:00 +0000

I. The Myth: I’m not ready…

My biggest fear before starting was the lack of experience. I used to think you had to be a senior software developer to even touch an Open Source project, let alone become part of its community. I won’t lie, the first moments are the hardest. Opening a repository and seeing hundreds of thousands of lines of code is intimidating, and the urge to quit immediately is strong. I was convinced it would take me months to make my first contribution. But then, I explored the project’s issues and stumbled upon the “beginner-friendly” labels. Seeing those was the spark that changed my mindset: Wait, I can actually do this too.

II. Choose the Project: why I chose SymPy

However, before making a contribution, you face the hardest decision: ‘Which project should I join?’. The answer is entirely up to you and what you love doing. Over the past few years, I’ve been diving deep into Python, and I have a genuine passion for mathematics. I really wanted to contribute under the Python Software Foundation umbrella, so I started exploring their projects. That’s when I stumbled upon SymPy, a Python library for symbolic math. Since I’ve always loved math at school, finding a project that perfectly merged my two biggest interests was an absolute goldmine.

III. The contribution reality (Not only code!)

The reality of contributing is that you don’t need to sit down and read a massive codebase for hours before writing a single line. You just need to find a task within your reach! While browsing the open issues, I found one about adding type hints, and I knew that was my starting point. I focused on a few specific files, particularly in the solvers module, that clearly needed some work. The best part? I didn't even have to download the entire library locally. I simply spun up a GitHub-hosted environment to edit and run the code directly from my browser. I analyzed the functions' inputs and outputs to accurately define their parameters and return types. Sure, I ran into some conflicts, but dealing with them gets surprisingly easy once you learn how to read MyPy error logs. It might look intimidating from the outside, but in every big project, there is a perfect mix of simple and complex tasks just waiting to be tackled.

IV. Where everything starts: the first Pull Request (PR)

As I mentioned earlier, the fear of not being experienced enough is real, and right after writing your first lines of code, that imposter syndrome might come rushing back. In open source, you can’t just push your code directly into the main project; it has to pass numerous automated tests and a code review. Mentors and reviewers can sometimes feel like unreachable giants, sitting there with a red marker ready to judge your work. But the reality is completely different: they are just developers like us who once started from scratch too. Most of the time, they are there to guide you and point out what needs improvement. Getting corrections doesn’t mean you aren’t welcome! It just means you need to iterate and adjust your work until it’s ready for a “Merge” — the moment your code officially joins the project. After some back-and-forth, fixing things, and learning a ton from my mentor’s feedback, my code was finally approved. And that is when the ultimate satisfaction hits: seeing that beautiful purple [MERGED] badge appear on your Pull Request. You can finally take a deep breath and say, 'I did it!'. Sure, a single PR might not change the world, but knowing your code is now part of something much bigger is an incredible feeling.

V. Open Source: everybody’s duty

It might seem like the Open Source world is completely out of reach for high schoolers, but the reality is the exact opposite! Contributing to an Open Source project teaches you crucial skills that you simply won’t learn in a traditional classroom:

Navigating Git on massive, real-world projects
Practicing technical English by communicating with international mentors and peers
Working with GitHub Actions (CI/CD) and strictly following formatting standards

But beyond the technical skills, contributing to Open Source feels like a moral duty. It’s our way of giving something back to the giant sea of free libraries and tools that we rely on every single day to build our own projects!

VI. Conclusion

Whether you are a high school student or anyone else looking to learn — you don’t need a fancy title to start contributing. Now is the perfect time! Hop on GitHub, do a quick search, and look for repositories with ‘good first issue’ or ‘beginner-friendly’ tags. The fix might seem small, but landing that first PR will give you the momentum you need to eventually tackle much bigger challenges. For me, this was just the first step on an exciting new path: I have officially submitted my proposal for the Google Summer of Code 2026! I’m hoping to spend my summer diving even deeper into SymPy. Fingers crossed!

VII. About the Author

Hi, I’m GiZano! I am a BSc in CS at University of Pisa, deeply passionate about IoT, local AI, and sustainable technology. As an active Open Source contributor, my goal is to dive deeper into the FOSS (Free and Open-Source Software) world and help make tech accessible to anyone.

Let's connect!
Linkedin
GitHub
Personal website

This article was originally published on my Medium blog.