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

how you can actually stay consistent together with your goals for 2026? This yr, I’ve decided that I don’t just want an inventory of goals. I would like a vision board backed by real metrics to trace my progress month after month.

The issue I’ve been facing these previous few years is fragmentation. There are one million apps on the market to enable you track finance, training, or day by day habits, but I could never discover a single, centralized tracker. Even harder was finding something that might scale: a system that follows a goal whether it’s day by day, weekly, monthly, quarterly or yearly.

For that reason, I made a decision to construct my very own goal tracker. This app is only one example of what works well for me, however the intention goes beyond this specific implementation. The goal is to share the product considering behind it: how you can design a system that aligns metrics, visuals, and structure in a way that really supports short and long-term goals.

Before jumping into the code, it’s vital to know the design decisions behind the app.

The Design

The logic

In point of fact, our ambition operates on different scales. Most trackers fail because they give attention to a single resolution (often tracking day by day habits). In my case, I needed a system that might support different frequencies of goals so i categorized my objectives into 2 categories:

• High-frequency goals (day by day / weekly): These are things I would like to do on a day by day 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 would like 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 those frequencies in a single system. This makes it possible to observe execution each day, but additionally maintain an outline of progress throughout the entire yr.

The User Interface

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

As an alternative, I selected a grid-based matrix. This permits to easily check boxes for habits or accomplished goals. In data visualization, an empty cell is just as informative as a filled one. Seeing gaps within the grid becomes a robust and really concrete signal. It immediately shows where consistency is missing and helps adjusting.

The Architecture

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

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

Python because the only programming language: I wanted to make use of a language I master. For that reason, I selected Streamlit for the UI and basic Python for the back-end logic. This alternative lets me construct an expert interface in pure Python without touching HTML or CSS. It’s great for small apps, though it has its own limits that we’ll 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.

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

Next is the Execution page, which I actually like. Here you will have boxes that you could check to trace your day by day, weekly, monthly, and yearly goals. You’ve each a day by day view and a long-term view that lets you validate your goals execution.

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

Let’s Jump Into the Code

Step 1: The Project Organization

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

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

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

DATABASE_URL = "your_connection_string_here"

Step 3: Constructing Your Tables on Neon

Within the Neon SQL Editor, execute this script to ascertain 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 day by day check-ins
• weekly_tracking: Logs completion of weekly milestones by ISO weeks.

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 over with Neon using a RealDictCursor, making data very easy to handle.

The “Brain” (core_logic.py)

That is crucial a part of the logic. Standard calendars are messy, so we use the “Thursday Rule” to remain mathematically accurate in metrics computation for our day by day 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 of the UI myself. I used a prompt to generate the primary model, then adjusted it to my needs.

The Orchestrator (app.py)

This primary file manages the landing page and navigation. Streamlit has its own session state to administer logins, which could be very helpful for a private use app or an MVP. Without mastering complex authentication concepts, you possibly can create a landing page where users can create an account and log in. Just consider this approach has its own security limitations for larger scales.

Step 5: The Deployment

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

Connect with Streamlit Cloud:

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

The “Secrets” Configuration: That is probably the most critical step. Since it’s best to never upload your secrets.toml file to GitHub, you have to provide those secrets on to the Streamlit platform:

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

Tips on how to copy your secret variable within the streamlit cloud

To run accurately on a distant server, ensure packages.txt (for Postgres connections on Linux) and requirements.txt are within the github repository.

And that’s it! If you desire to create your personal visual board, you possibly can follow these steps. All of the code is out there here: https://github.com/sbendimerad/VisionBoard2026

Should you don’t wish to deploy your personal, be at liberty to make use of my live version here: Vision Board 2026

For the app to run accurately on a distant server, you want to ensure two specific files are perfect:

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

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

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

In case you don’t wish to deploy yours, you possibly can absolutely use the url I actually have deployed free of charge just here: Visionboard2026

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

Please consider that while Streamlit and Python are perfect for making a quick, functional app, this isn’t necessarily a long-term solution for a full-scale business application. For an expert, high-traffic product, you’d ultimately need a dedicated front-end and back-end architecture.

🤝 Stay Connected

Should you enjoyed this text, be at liberty to follow me on LinkedIn for more honest insights about AI, Data Science, and careers.

👉 LinkedIn: 

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

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