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

How can you actually stay on track with your 2026 goals? This year, I decided I didn't just want a list of goals. I want a vision board backed by real metrics to track my progress from month to month.

The problem I have been dealing with for the past few years is separation. There are a million apps out there that can help you track finances, training, or daily habits, but I couldn't find a single, central tracker. Even more difficult was finding something measurable: a plan that follows a goal whether it be daily, weekly, monthly, quarterly or annually.

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

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

---

The design

The concept

In fact, our desire works on different scales. Most trackers fail because they focus on one fix (usually tracking daily habits). In my case, I needed a system that can support different frequency of goals to divide my goals into 2 categories:

• High frequency goals (daily / weekly): These are things I want to do every day or every week. 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 every month or every year. I call these strategic goals because they require less repetition, but more direction and adjustment over time.

The application I designed was intended to capture all these waves with one system. This makes it possible to monitor daily performance, but also to keep an overview of progress throughout the year.

User interface

When it comes 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 you to simply check the boxes for habits or completed goals. In the data view, an empty cell has information as filled. Seeing gaps in the grid becomes a stronger and stronger signal. It quickly shows where compatibility is lacking and helps to fix it.

---

Architecture

For this project, I have two main structural requirements:

Zero Database Management: I didn't want to install anything locally or manage servers. I have chosen Neona cloud-based PostgreSQL database, to serve as a back-end server for the application.

Python as the only programming language: I wanted to use the language I know well. For this reason, I chose Broadcast for UI and basic Python for end-end logic. This option allows me to build a functional interface in pure Python without touching HTML or CSS. It is suitable for small applications, although it has its limitations which 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 in to the application.

About the author: Landing page viewe

Once you're logged in, you get to Strategy Setup page. Here, you can enter your goal by name and category. I've created eight categories that you can change once you have the code. Throughout this demo, I've kept some of my non-secret goals visible. Some are human and are hidden in red.

By the author: Look at the setupge

Next is The execution page, which I like very much. Here you have boxes to 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 ensure the implementation of your goals.

By author: Issue page view (Daily setup)

About the author: Execution page view (Long time oftup)

To finish, I created a Reports page. It provides an overview of your goal setting. This is my favorite part because it helps me see if I've met my daily, weekly, and long-term goals. If the goal is late, the system will show it clearly.

About the author: View reportt page

---

Let's jump on the bandwagon

Step 1: Project Organization

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

By author

Step 2: Back end (Neon & Database set)

Create a free account on Neon.tech. Once you've created the project, get the Connection String and paste it into .streamlit/secrets.toml like this:

DATABASE_URL = "your_connection_string_here"

About the author: How to create a project in Neon

About the author: How to find your connection string

Step 3: Building Your Tables in Neon

In the Neon SQL editor, run this script to get the five basic tables:

• long-term_tracking: Maintains Monthly, Quarterly, and Annual records of strategic progress.
• users: Stores secure account information.
• goals_catalog: This “Architect” table shows the goal headings, categories, and frequencies of occurrence.
• daily_tracking: It stores data on all high-frequency entries every day
• weekly_tracking: Logs are completed for weekly ISO milestones.

By the author: How to build your own tables on the database

Step 4: Natureent Edit

conda create -n vision_app python=3.9

conda activate vision_app

pip install -r requirements.txt

Connection script (db_utils.py):

This script allows Python to talk to Neon using RealDictCursor, making the data much easier to handle.

“Mind” (core_logic.py)

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

Visual Design with AI (ui_pages.py)

Once your database and logic are ready, don't struggle with the UI syntax. To be honest, I didn't write the whole UI myself. I used the information to generate an initial model, then modified it to suit my needs.

Orchestrator (app.py)

This main file manages the landing page and navigation. Streamlit has it session status login management, which is very useful for personal use application or MVP. Without understanding complex authentication concepts, you can create a landing page where users can create an account and login. Just remember that this method has its limitations for security at large scales.

Step 5: I Demployment

Make sure all your files are committed and pushed to the GitHub repository.

Connect to the streamlCloud:

1. Sign in to share.streamlit.io using your GitHub account.
2. Click “Noperating system. “
3. Choose your repository, branch, and main file (app.py).

“Secrets” Configuration: This is a very serious step. As it should never upload your own secrets.toml file on GitHub, you must provide those secrets directly to the Streamlit platform:

1. In the application settings, go to “Secrets“ part.
2. Paste yours DATABASE_URL as it appears in your local private file.

About the author: How to copy your private variables to the light cloud

For proper operation on the remote server, confirm packages.txt (with Postgres connection on Linux) and requirements.txt they are in the github repository.

And that's it! If you want to create your own virtual board, you can follow these steps. All codes are available here:

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

For the application to work properly on the remote server, you need to ensure that two specific files are correct:

packages.txt: This is important for Postgres connections. Streamlit Cloud runs on Linux, and requires 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 virtual board, you can follow these steps, all the code is here:

In case you don't want to use your own, you can absolutely use the url I posted for free here: Visionboard2026

I hope this app helps you set and track your goals for 2026! 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 great for creating a quick, functional application, this is not a long-term solution for a full business application. For a professional, high-traffic product, you'll 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 reliable information about AI, Data Science, and careers.

👉 LinkedIn: Sabrhas Bendimerad

👉 Average:

👉 Instagram: