The 2026 Goal Tracker: How I Built a Data-Driven Vision Board Using Python, Streamlit, and Neon

how to actually stay consistent with your goals for 2026? This year, I’ve decided that I don’t just want a list of goals. I want a vision board backed by real metrics to track my progress month after month.

The problem I’ve been facing these last few years is fragmentation. There are a million apps out there to help you track finance, training, or daily habits, but I could never find a single, centralized tracker. Even harder was finding something that could scale: a system that follows a goal whether it’s daily, weekly, monthly, quarterly or yearly.

For this reason, I decided to build my own goal tracker. This app is just one example of what works well for me, but the intention goes beyond this specific implementation. The goal is to share the product thinking behind it: how to design a system that aligns metrics, visuals, and structure in a way that actually supports short and long-term goals.

Before jumping into the code, it’s important to understand the design decisions behind the app.

The Design

The logic

In reality, our ambition operates on different scales. Most trackers fail because they focus on a single resolution (often tracking daily habits). In my case, I needed a system that could support different frequencies of goals so i categorized my objectives into 2 categories:

• High-frequency goals (daily / weekly): These are things I want to do on a daily or weekly basis. I call these habits because they require things to be checked quickly and with high frequency.
• Low-frequency goals (monthly / yearly): These are things I want to do on a monthly or yearly basis. I call these strategic goals because they require less repetition, but more direction and adjustments over time.

The app I designed was meant to capture all of these frequencies in a single system. This makes it possible to monitor execution on a daily basis, but also maintain an overview of progress throughout the whole year.

The User Interface

When it came to the interface, I deliberately avoided complexity. I’m not a UI expert, and I didn’t want an app filled with buttons, menus, or unnecessary interactions.

Instead, I chose a grid-based matrix. This allows to simply check boxes for habits or completed goals. In data visualization, an empty cell is just as informative as a filled one. Seeing gaps in the grid becomes a powerful and very concrete signal. It immediately shows where consistency is missing and helps adjusting.

The Architecture

For this project, I had two important requirements for the architecture:

Zero Database Management: I didn’t want to install anything locally or manage servers. I chose Neon, a cloud-free PostgreSQL database, to act as the back server of the app.

Python as the only programming language: I wanted to use a language I master. For this reason, I chose Streamlit for the UI and basic Python for the back-end logic. This choice lets me build a professional interface in pure Python without touching HTML or CSS. It is great for small apps, though it has its own limits that we will discuss later.

A Quick tour of the App

Let’s start with the landing page. This page allows the user to create an account and log into the app.

By the author: View of the landing page

Once logged in, you arrive at the Strategy Setup page. Here, you can enter your goal with a name and category. I’ve created eight categories that you can change once you have the code. For the rest of this demo, I’ve kept only some of my non-confidential goals visible. The rest are personal and hidden with the red color.

By the author: View of the setup page

Next is the Execution page, which I really like. Here you have boxes that you can check to track your daily, weekly, monthly, and yearly goals. You have both a daily view and a long-term view that allows you to validate your goals execution.

By the author: View of the execution page (The daily setup)

By the author: View of the execution page (The long-term setup)

To finish, I’ve created a Reports page. It provides a snapshot of your goal execution. This is my favorite part because it helps me see if I’ve reached my daily, weekly, and long-term goals. If a goal is late, the system will clearly display it.

By the author: View of the report page

Let’s Jump Into the Code

Step 1: The Project Organization

A professional app needs a clean structure so the “logic” is separated from the “visuals”. Create a folder named vision_2026 with this structure:

By the author

Step 2: The back-end (Neon & Database Setup)

Create a free account on Neon.tech. Once you create a project, retrieve your Connection String and paste it into .streamlit/secrets.toml exactly like this:

DATABASE_URL = "your_connection_string_here"

By the author: How to create a project on Neon

By the author: How to retrieve your connection string

Step 3: Building Your Tables on Neon

In the Neon SQL Editor, execute this script to establish the five fundamental tables:

• long_term_tracking: Keeps Monthly, Quarterly, and Yearly records of strategic progress.
• users: Keeps secure account information.
• goals_catalog: This “Architect” table outlines goal titles, classifications, and occurrence frequencies.
• daily_tracking: Keeps data on all high-frequency daily check-ins
• weekly_tracking: Logs completion of weekly milestones by ISO weeks.

By the author: How to create your tables on the database

Step 4: Environment Set Up

conda create -n vision_app python=3.9

conda activate vision_app

pip install -r requirements.txt

The Connection Script (db_utils.py):

This script allows Python to talk to Neon using a RealDictCursor, making data very easy to handle.

The “Brain” (core_logic.py)

This is the most important part of the logic. Standard calendars are messy, so we use the “Thursday Rule” to stay mathematically accurate in metrics computation for our daily and weekly goals.

Designing Visuals with AI (ui_pages.py)

Once your database and logic are ready, don’t struggle with UI syntax. To be honest, I didn’t code all the UI myself. I used a prompt to generate the first model, then adjusted it to my needs.

The Orchestrator (app.py)

This main file manages the landing page and navigation. Streamlit has its own session state to manage logins, which is very helpful for a personal use app or an MVP. Without mastering complex authentication concepts, you can create a landing page where users can create an account and log in. Just keep in mind this approach has its own security limitations for larger scales.

Step 5: The Deployment

Ensure all your files are committed and pushed to a GitHub repository.

Connect to Streamlit Cloud:

1. Sign in to share.streamlit.io using your GitHub account.
2. Click “New app.”
3. Select your repository, the branch, and the main file (app.py).

The “Secrets” Configuration: This is the most critical step. Since you should never upload your secrets.toml file to GitHub, you must provide those secrets directly to the Streamlit platform:

1. In the deployment settings, go to the “Secrets“ section.
2. Paste your DATABASE_URL exactly as it appears in your local secrets file.

By the author: How to copy your secret variable in the streamlit cloud

To run correctly on a remote server, ensure packages.txt (for Postgres connections on Linux) and requirements.txt are in the github repository.

And that’s it! If you want to create your own visual board, you can follow these steps. All the code is available here: https://github.com/sbendimerad/VisionBoard2026

If you don’t want to deploy your own, feel free to use my live version here: Vision Board 2026

For the app to run correctly on a remote server, you need to ensure two specific files are perfect:

packages.txt: This is essential for Postgres connections. Streamlit Cloud runs on Linux, and it needs a system-level driver to talk to your database.

requirements.txt: This tells the cloud which Python libraries to install.

And that’s it 🙂 If you want to create your own visual board, you can follow these steps, all the code is here: https://github.com/sbendimerad/VisionBoard2026

In case you don’t want to deploy yours, you can absolutely use the url I have deployed for free just here: Visionboard2026

I hope this app helps you set and track your 2026 goals! If you want to add any new features, don’t hesitate to fork the project.

Please keep in mind that while Streamlit and Python are perfect for creating a quick, functional app, this isn’t necessarily a long-term solution for a full-scale business application. For a professional, high-traffic product, you would ultimately need a dedicated front-end and back-end architecture.

🤝 Stay Connected

If you enjoyed this article, feel free to follow me on LinkedIn for more honest insights about AI, Data Science, and careers.

👉 LinkedIn: Sabrine Bendimerad

👉 Medium: https://medium.com/@sabrine.bendimerad1

👉 Instagram: https://tinyurl.com/datailearn