How to Build a Habit Tracker App with Streamlit and Python

2202 words

11 minutes

How to Build a Habit Tracker App with Streamlit and Python

2025-06-29

Project

Python

/

Streamlit

/

Web App

/

Productivity

/

Data Visualization

Building a Habit Tracker App with Streamlit and Python#

Building tools to support personal development or project management often involves creating applications that can track progress over time. A habit tracker is a prime example, providing a visual and interactive way to monitor the consistency of activities. Developing such an application from scratch can be a complex undertaking, requiring expertise in frontend development, backend logic, and database management. However, using Python and the Streamlit library simplifies this process significantly, allowing for the creation of interactive web applications with minimal code and no need for separate frontend frameworks.

Streamlit is an open-source Python library specifically designed for machine learning and data science teams to create and share beautiful, custom web apps in minutes. Its strength lies in its simplicity and Python-native approach, enabling developers to build interactive interfaces directly from Python scripts. This makes it an excellent choice for prototyping and deploying simple, data-driven applications like a habit tracker.

Why Choose Streamlit for a Habit Tracker?#

Developing a habit tracking application requires handling data input, storage, display, and potentially visualization. Traditional web development stacks involve multiple languages and frameworks. Streamlit streamlines this by:

Rapid Prototyping: Turn data scripts into shareable web apps quickly. The iterative development cycle with Streamlit is very fast.
Python Ecosystem: Leverage the extensive Python libraries for data handling (pandas), visualization (Matplotlib, Plotly, Altair), and file operations.
No Frontend Expertise Required: Write the entire application logic and interface solely in Python. Streamlit handles the HTML, CSS, and JavaScript automatically.
Interactivity: Easily add sliders, buttons, text inputs, checkboxes, and other widgets to build interactive elements.
Data Flow: Streamlit’s data flow model simplifies state management for many common application patterns.

Compared to building a mobile app or using a complex web framework like Django or Flask with a separate frontend, Streamlit offers a path to a functional application much faster, especially for internal tools or personal projects.

Core Concepts for a Streamlit Habit Tracker#

Understanding a few key concepts is essential before building the application:

Streamlit Script Execution: A Streamlit app runs from top to bottom whenever a user interacts with a widget. State needs to be managed carefully.
Widgets: Interactive elements like st.button, st.checkbox, st.date_input, st.text_input are used for user interaction.
st.session_state: This dictionary-like object allows persistent state across user interactions within a single user’s session. It’s crucial for remembering data and application state.
Data Structure: How the habit data is organized. A common and efficient structure is a pandas DataFrame or a list of dictionaries, storing habit names, dates, and completion status.
Data Persistence: Streamlit apps reset when the script re-runs or the server restarts. Saving data to a file (like CSV or JSON) or connecting to a database is necessary for long-term storage. For a simple app, saving to a local file is often sufficient.
Visualization: Presenting habit consistency visually using charts or calendars can significantly improve the app’s usability.

Building the Habit Tracker: A Step-by-Step Guide#

This guide outlines the process of creating a basic habit tracker using Streamlit and Python, focusing on core functionality: adding habits, tracking completion for a specific date, and saving/loading data.

Step 1: Project Setup#

Begin by installing the necessary libraries. The primary library is streamlit, and pandas is highly recommended for efficient data handling.

1
pip install streamlit pandas

Create a Python file (e.g., habit_tracker_app.py) where the application code will reside.

Step 2: Data Structure Design#

Design how the habit data will be stored. A pandas DataFrame is suitable, with columns to record essential information.

Column Name	Data Type	Description
`Habit Name`	string	The name of the habit (e.g., “Read for 30 mins”)
`Date`	date	The date the habit was tracked for
`Completed`	boolean	Whether the habit was completed on that date

Initialize the DataFrame or load it from a persistent source. Using st.session_state to hold the DataFrame is key for maintaining data within a session without constantly re-loading from storage during interactions.

1
import streamlit as st
2
import pandas as pd
3
from datetime import date
4

5
# Initialize session state for data
6
if 'habit_data' not in st.session_state:
7
    # Create an empty DataFrame if no data exists
8
    st.session_state['habit_data'] = pd.DataFrame(columns=['Habit Name', 'Date', 'Completed'])
9
    # Ensure 'Date' column is datetime type for easier handling
10
    st.session_state['habit_data']['Date'] = pd.to_datetime(st.session_state['habit_data']['Date'])
11

12
# Placeholder function to load data (implement file loading later)
13
def load_data():
14
    # In a real app, load from CSV/JSON/DB here
15
    # For this example, we rely on session_state unless implementing persistence
16
    pass # No loading needed if using only session_state
17

18
# Placeholder function to save data (implement file saving later)
19
def save_data():
20
    # In a real app, save to CSV/JSON/DB here
21
    st.session_state['habit_data'].to_csv('habit_data.csv', index=False)
22
    st.success("Data saved!")
23

24
# Load data when app starts (if implementing persistence)
25
# load_data()

Step 3: Add New Habits#

Provide a way for users to define the habits they want to track. A text input and a button are suitable widgets.

1
st.title("Simple Habit Tracker")
2

3
# Section to add new habits
4
st.header("Add New Habit")
5
new_habit_name = st.text_input("Enter habit name:")
6

7
if st.button("Add Habit"):
8
    if new_habit_name:
9
        # Add the new habit name to a list of unique habits
10
        # We need a separate list/set of unique habit names for display
11
        if 'unique_habits' not in st.session_state:
12
            st.session_state['unique_habits'] = []
13

14
        if new_habit_name not in st.session_state['unique_habits']:
15
            st.session_state['unique_habits'].append(new_habit_name)
16
            st.success(f"Habit '{new_habit_name}' added!")
17
        else:
18
            st.warning(f"Habit '{new_habit_name}' already exists.")
19
    else:
20
        st.warning("Please enter a habit name.")

Note: The unique habits list is stored separately from the tracking data for simpler display and selection later.

Step 4: Track Habits for a Specific Date#

Allow users to select a date and mark habits as completed or not completed for that date. A date input and checkboxes are effective here.

1
st.header("Track Habits")
2

3
# Select date for tracking
4
selected_date = st.date_input("Select a date:", date.today())
5

6
if 'unique_habits' in st.session_state and st.session_state['unique_habits']:
7
    st.subheader(f"Habits for {selected_date.strftime('%Y-%m-%d')}")
8

9
    # Filter data for the selected date
10
    date_data = st.session_state['habit_data'][st.session_state['habit_data']['Date'].dt.date == selected_date]
11

12
    updated_completions = {}
13
    for habit in st.session_state['unique_habits']:
14
        # Check if the habit is already recorded for this date
15
        habit_record = date_data[date_data['Habit Name'] == habit]
16
        initial_status = False
17
        if not habit_record.empty:
18
            initial_status = habit_record['Completed'].iloc[0]
19

20
        # Use a unique key for each checkbox
21
        checkbox_key = f"checkbox_{habit}_{selected_date}"
22
        is_completed = st.checkbox(f"Completed: {habit}", value=initial_status, key=checkbox_key)
23

24
        updated_completions[habit] = is_completed
25

26
    # Button to save tracking changes for the selected date
27
    if st.button(f"Save Tracking for {selected_date.strftime('%Y-%m-%d')}"):
28
        # Prepare data to add/update
29
        records_to_add = []
30
        # Remove existing records for this date to avoid duplicates before adding new ones
31
        st.session_state['habit_data'] = st.session_state['habit_data'][
32
            (st.session_state['habit_data']['Date'].dt.date != selected_date) | # Keep records from other dates
33
            (~st.session_state['habit_data']['Habit Name'].isin(updated_completions.keys())) # Keep records for habits not being tracked on this date
34
        ].copy() # Use .copy() to avoid SettingWithCopyWarning
35

36
        for habit, completed_status in updated_completions.items():
37
            records_to_add.append({'Habit Name': habit, 'Date': selected_date, 'Completed': completed_status})
38

39
        if records_to_add:
40
             # Append new records
41
            new_data = pd.DataFrame(records_to_add)
42
            new_data['Date'] = pd.to_datetime(new_data['Date']) # Ensure date is datetime
43
            st.session_state['habit_data'] = pd.concat([st.session_state['habit_data'], new_data], ignore_index=True)
44

45
        st.success(f"Tracking updated for {selected_date.strftime('%Y-%m-%d')}")
46

47
else:
48
    st.info("Add some habits first in the 'Add New Habit' section.")

This section displays checkboxes for each defined habit. The state of the checkbox is initialized based on existing data for the selected date. Clicking “Save Tracking” updates or adds records in the st.session_state['habit_data'] DataFrame.

Step 5: Display Tracking Data#

Show the raw tracking data in a table for verification.

1
st.header("Tracking Data")
2
st.dataframe(st.session_state['habit_data'])

Step 6: Data Persistence (Saving and Loading)#

Implement functions to save the habit_data DataFrame to a file and load it when the app starts. A simple CSV file is used here.

Modify the initial setup (Step 2) and add buttons for saving/loading.

1
# ... (previous imports and initial session_state setup) ...
2

3
DATA_FILE = 'habit_data.csv'
4
UNIQUE_HABITS_FILE = 'unique_habits.json' # Using JSON for simplicity for unique habits
5

6
# Function to load data from CSV
7
def load_data():
8
    try:
9
        df = pd.read_csv(DATA_FILE)
10
        df['Date'] = pd.to_datetime(df['Date']).dt.date # Store date as date object
11
        return df
12
    except FileNotFoundError:
13
        return pd.DataFrame(columns=['Habit Name', 'Date', 'Completed'])
14

15
# Function to save data to CSV
16
def save_data(df):
17
    df['Date'] = df['Date'].astype(str) # Convert date objects to string for saving
18
    df.to_csv(DATA_FILE, index=False)
19

20
import json
21
# Function to load unique habits from JSON
22
def load_unique_habits():
23
    try:
24
        with open(UNIQUE_HABITS_FILE, 'r') as f:
25
            return json.load(f)
26
    except (FileNotFoundError, json.JSONDecodeError):
27
        return []
28

29
# Function to save unique habits to JSON
30
def save_unique_habits(habits_list):
31
    with open(UNIQUE_HABITS_FILE, 'w') as f:
32
        json.dump(habits_list, f)
33

34

35
# Initialize session state OR load data
36
if 'habit_data' not in st.session_state:
37
    st.session_state['habit_data'] = load_data()
38

39
if 'unique_habits' not in st.session_state:
40
    st.session_state['unique_habits'] = load_unique_habits()
41
    # Also, initialize unique habits from loaded data if file was empty
42
    if not st.session_state['unique_habits'] and not st.session_state['habit_data'].empty:
43
         st.session_state['unique_habits'] = st.session_state['habit_data']['Habit Name'].unique().tolist()
44

45

46
st.title("Simple Habit Tracker")
47

48
# Add Save Button
49
if st.button("Save All Data"):
50
    # Convert date column back to datetime objects before saving if they were stored as date objects
51
    # Or ensure consistent storage format.
52
    # For this example, we load as date.date and convert to string for saving CSV.
53
    # Let's refine date handling for consistency. Store as datetime objects in session state.
54
    st.session_state['habit_data']['Date'] = pd.to_datetime(st.session_state['habit_data']['Date']) # Ensure datetime in session state
55

56
    save_data(st.session_state['habit_data'])
57
    save_unique_habits(st.session_state['unique_habits'])
58
    st.success("Data and habits saved!")
59

60

61
# ... (Add New Habit section - needs minor modification to save unique habits) ...
62
st.header("Add New Habit")
63
new_habit_name = st.text_input("Enter habit name:")
64

65
if st.button("Add Habit"):
66
    if new_habit_name:
67
        if 'unique_habits' not in st.session_state:
68
             st.session_state['unique_habits'] = []
69

70
        if new_habit_name not in st.session_state['unique_habits']:
71
            st.session_state['unique_habits'].append(new_habit_name)
72
            save_unique_habits(st.session_state['unique_habits']) # Save unique habits immediately
73
            st.success(f"Habit '{new_habit_name}' added! Remember to Save All Data periodically.")
74
        else:
75
            st.warning(f"Habit '{new_habit_name}' already exists.")
76
    else:
77
        st.warning("Please enter a habit name.")
78

79

80
# ... (Track Habits section - no major changes needed, it operates on session_state['habit_data']) ...
81
st.header("Track Habits")
82

83
# Select date for tracking
84
selected_date = st.date_input("Select a date:", date.today())
85

86
if 'unique_habits' in st.session_state and st.session_state['unique_habits']:
87
    st.subheader(f"Habits for {selected_date.strftime('%Y-%m-%d')}")
88

89
    # Ensure comparison with datetime objects if session state stores datetime
90
    date_data = st.session_state['habit_data'][st.session_state['habit_data']['Date'].dt.date == selected_date]
91

92
    updated_completions = {}
93
    for habit in st.session_state['unique_habits']:
94
        habit_record = date_data[date_data['Habit Name'] == habit]
95
        initial_status = False
96
        if not habit_record.empty:
97
            initial_status = habit_record['Completed'].iloc[0]
98

99
        checkbox_key = f"checkbox_{habit}_{selected_date}"
100
        is_completed = st.checkbox(f"Completed: {habit}", value=initial_status, key=checkbox_key)
101

102
        updated_completions[habit] = is_completed
103

104
    if st.button(f"Save Tracking for {selected_date.strftime('%Y-%m-%d')}"):
105
        # Convert selected_date to datetime for consistent comparison/storage
106
        selected_datetime = pd.to_datetime(selected_date)
107

108
        # Remove existing records for this date and habit name
109
        st.session_state['habit_data'] = st.session_state['habit_data'][
110
             (st.session_state['habit_data']['Date'].dt.date != selected_datetime.date()) |
111
             (~st.session_state['habit_data']['Habit Name'].isin(updated_completions.keys())) # This part is optional depending on desired behavior
112
        ].copy()
113

114
        records_to_add = []
115
        for habit, completed_status in updated_completions.items():
116
             # Only add if completed (optional, could add False too)
117
             # Adding both True/False allows explicit tracking of non-completion
118
             records_to_add.append({'Habit Name': habit, 'Date': selected_datetime, 'Completed': completed_status})
119

120

121
        if records_to_add:
122
             new_data = pd.DataFrame(records_to_add)
123
             st.session_state['habit_data'] = pd.concat([st.session_state['habit_data'], new_data], ignore_index=True)
124
             st.session_state['habit_data']['Date'] = pd.to_datetime(st.session_state['habit_data']['Date']) # Ensure datetime type after concat
125

126

127
        st.success(f"Tracking updated for {selected_date.strftime('%Y-%m-%d')}")
128

129
else:
130
    st.info("Add some habits first in the 'Add New Habit' section.")
131

132

133
# ... (Tracking Data Display section - no changes) ...
134
st.header("Tracking Data")
135
st.dataframe(st.session_state['habit_data'])

Step 7: Basic Visualization#

Add a simple visualization to show progress, such as completion count per habit.

1
st.header("Habit Progress")
2

3
if not st.session_state['habit_data'].empty:
4
    # Calculate completion counts per habit
5
    completion_counts = st.session_state['habit_data'].groupby('Habit Name')['Completed'].sum().reset_index()
6

7
    if not completion_counts.empty:
8
        st.subheader("Total Completions per Habit")
9
        # Use Streamlit's built-in bar chart
10
        st.bar_chart(completion_counts.set_index('Habit Name'))
11

12
    # Optional: Show completion rate over time for a selected habit
13
    if 'unique_habits' in st.session_state and st.session_state['unique_habits']:
14
        st.subheader("Completion Rate Over Time")
15
        selected_habit_viz = st.selectbox("Select a habit to visualize:", st.session_state['unique_habits'])
16

17
        if selected_habit_viz:
18
            habit_data_filtered = st.session_state['habit_data'][st.session_state['habit_data']['Habit Name'] == selected_habit_viz].copy()
19

20
            if not habit_data_filtered.empty:
21
                # Sort by date
22
                habit_data_filtered = habit_data_filtered.sort_values(by='Date')
23

24
                # Create a time series of completion status (1 for True, 0 for False)
25
                habit_data_filtered['Completed_Value'] = habit_data_filtered['Completed'].astype(int)
26

27
                st.line_chart(habit_data_filtered.set_index('Date')['Completed_Value'])
28
            else:
29
                st.info("No data tracked yet for this habit.")
30
else:
31
    st.info("Track some habits to see progress.")

This adds a bar chart showing the total number of times each habit has been marked as completed and a line chart showing completion status over time for a selected habit. Streamlit’s built-in charting functions (st.bar_chart, st.line_chart) are convenient for quick visualizations using pandas DataFrames.

Step 8: Running the App#

Save the Python file (e.g., habit_tracker_app.py). Open a terminal or command prompt, navigate to the directory where the file is saved, and run the command:

1
streamlit run habit_tracker_app.py

This command starts a local web server, and your habit tracker application will open in a web browser.

Practical Application Example#

Consider an individual aiming to improve consistency in several areas: daily coding practice, reading a chapter of a book, and taking a 30-minute walk. They could use the Streamlit habit tracker to:

Add Habits: Input “Coding Practice”, “Read Book”, “Walk 30 mins” into the “Add New Habit” section.
Track Daily: Each evening, they open the app, select the current date, and check the boxes for the habits they completed.
Monitor Progress: Use the “Habit Progress” section to see how many times they’ve completed each habit in total and observe the trend over time using the line chart.
Persistence: Click “Save All Data” periodically to ensure their tracking history is stored in the habit_data.csv file.

This demonstrates how the simple Streamlit app provides a functional, visual tool for self-monitoring without the overhead of more complex development environments. The flexibility of Python and Streamlit allows for future expansion, such as adding features like streak counting, goal setting, or more sophisticated visualizations.

Summary: Key Takeaways for Building a Habit Tracker with Streamlit#

Streamlit enables rapid development of interactive web applications using only Python.
st.session_state is essential for managing data and application state across user interactions within a session.
A pandas DataFrame provides a flexible structure for storing habit tracking data (Habit Name, Date, Completed).
Data persistence requires saving the DataFrame to a file (like CSV) or a database and loading it on application start.
Streamlit widgets (st.text_input, st.button, st.date_input, st.checkbox) are used to build the user interface for adding habits and tracking completion.
Basic visualizations can be easily added using Streamlit’s built-in charting functions or by integrating libraries like Matplotlib, Plotly, or Altair.
Running the app is straightforward using the streamlit run command.
The approach is highly suitable for personal tools, internal dashboards, or prototypes where rapid development and Python integration are priorities.