Why Dashboard Integration Matters
Real-time dashboards provide instant visibility into program performance. This tutorial shows you how to build interactive dashboards that automatically update from your M&E data, giving stakeholders immediate access to key indicators, trends, and alerts.

Popular Dashboard Options for M&E:

# data_connector.py
import pandas as pd
import os
from datetime import datetime
import json
class DashboardDataConnector:
    """Connects to data sources for real-time dashboard updates."""
    
    def __init__(self, data_source='excel', file_path='indicator_data.xlsx', 
                 refresh_interval=60):
        self.data_source = data_source
        self.file_path = file_path
        self.refresh_interval = refresh_interval  # seconds
        self.last_refresh = None
        self.cached_data = None
        self.cached_metrics = None
    
    def load_data(self, force_refresh=False):
        """Load data with optional caching."""
        if not force_refresh and self.cached_data is not None:
            return self.cached_data
        
        if self.data_source == 'excel':
            if not os.path.exists(self.file_path):
                raise FileNotFoundError(f"Data file not found: {self.file_path}")
            df = pd.read_excel(self.file_path)
        elif self.data_source == 'google_sheets':
            # Google Sheets integration
            df = self._load_google_sheets()
        elif self.data_source == 'api':
            # API integration
            df = self._load_api_data()
        else:
            raise ValueError(f"Unsupported data source: {self.data_source}")
        
        # Clean and prepare data
        df = self._prepare_data(df)
        
        self.cached_data = df
        self.last_refresh = datetime.now()
        self.cached_metrics = self.calculate_metrics(df)
        
        return df
    
    def _prepare_data(self, df):
        """Clean and prepare data for dashboard."""
        if 'date' in df.columns:
            df['date'] = pd.to_datetime(df['date'])
        
        if 'target' in df.columns and 'actual' in df.columns:
            df['achievement'] = (df['actual'] / df['target'] * 100).round(1)
        
        if 'status' not in df.columns:
            # Auto-assign status based on achievement
            conditions = [
                df['achievement'] >= 90,
                df['achievement'] >= 70,
                df['achievement'] < 70 ] choices = ['on_track', 'at_risk', 'off_track'] df['status'] = pd.Series(pd.cut(df['achievement'], bins=[0, 70, 90, 100], labels=choices)) return df def calculate_metrics(self, df): """Calculate key dashboard metrics.""" total = len(df) on_track = len(df[df['status'] == 'on_track']) if 'status' in df else 0 at_risk = len(df[df['status'] == 'at_risk']) if 'status' in df else 0 off_track = len(df[df['status'] == 'off_track']) if 'status' in df else 0 avg_achievement = df['achievement'].mean() if 'achievement' in df else 0 # Category performance category_perf = {} if 'category' in df.columns and 'achievement' in df.columns: category_perf = df.groupby('category')['achievement'].mean().to_dict() # Trend data trend_data = {} if 'date' in df.columns and 'achievement' in df.columns: df_trend = df.groupby('date')['achievement'].mean().reset_index() trend_data = df_trend.to_dict('records') return { 'total_indicators': total, 'on_track': on_track, 'at_risk': at_risk, 'off_track': off_track, 'avg_achievement': avg_achievement, 'category_performance': category_perf, 'trend_data': trend_data, 'last_refresh': datetime.now().strftime('%Y-%m-%d %H:%M') } def get_data(self): """Get data with auto-refresh if needed.""" if self.cached_data is None: return self.load_data() # Check if refresh needed if self.last_refresh: elapsed = (datetime.now() - self.last_refresh).total_seconds() if elapsed > self.refresh_interval:
                self.load_data(force_refresh=True)
        
        return self.cached_data
    
    def get_metrics(self):
        """Get calculated metrics."""
        self.get_data()  # Triggers refresh if needed
        return self.cached_metrics
    
    def _load_google_sheets(self):
        """Load data from Google Sheets."""
        # Implementation for Google Sheets
        pass
    
    def _load_api_data(self):
        """Load data from API."""
        # Implementation for API
        pass

# dashboard_streamlit.py
import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from data_connector import DashboardDataConnector
import time
# Page configuration
st.set_page_config(
    page_title="M&E Performance Dashboard",
    page_icon="📊",
    layout="wide"
)
# Initialize data connector
@st.cache_resource
def init_connector():
    return DashboardDataConnector('excel', 'indicator_data.xlsx', refresh_interval=30)
connector = init_connector()
# Title
st.title("📊 M&E Performance Dashboard")
st.caption(f"Last updated: {connector.get_metrics().get('last_refresh', 'N/A')}")
# Auto-refresh
auto_refresh = st.sidebar.checkbox("Auto-refresh every 30 seconds", value=True)
if auto_refresh:
    time.sleep(30)
    st.experimental_rerun()
# Load data
df = connector.get_data()
metrics = connector.get_metrics()
# Layout: Key metrics row
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
    st.metric("Total Indicators", metrics['total_indicators'])
with col2:
    st.metric("✅ On Track", metrics['on_track'], delta="On Track")
with col3:
    st.metric("⚡ At Risk", metrics['at_risk'], delta="At Risk")
with col4:
    st.metric("❌ Off Track", metrics['off_track'], delta="Off Track")
with col5:
    st.metric("📊 Avg Achievement", f"{metrics['avg_achievement']:.1f}%")
st.divider()
# Layout: Charts row
col1, col2 = st.columns(2)
with col1:
    # Status Distribution
    st.subheader("Status Distribution")
    status_counts = df['status'].value_counts()
    fig = px.pie(
        values=status_counts.values,
        names=status_counts.index,
        color=status_counts.index,
        color_discrete_map={'on_track': '#28a745', 'at_risk': '#ffc107', 'off_track': '#dc3545'}
    )
    st.plotly_chart(fig, use_container_width=True)
with col2:
    # Category Performance
    if 'category' in df.columns:
        st.subheader("Category Performance")
        category_avg = df.groupby('category')['achievement'].mean().sort_values()
        fig = px.bar(
            x=category_avg.values,
            y=category_avg.index,
            orientation='h',
            color=category_avg.values,
            color_continuous_scale='RdYlGn',
            labels={'x': 'Average Achievement (%)', 'y': 'Category'}
        )
        st.plotly_chart(fig, use_container_width=True)
# Layout: Full width charts
st.subheader("Performance Trends")
if 'date' in df.columns:
    df_trend = df.groupby('date')['achievement'].mean().reset_index()
    fig = px.line(
        df_trend,
        x='date',
        y='achievement',
        title='Overall Achievement Over Time',
        labels={'achievement': 'Achievement (%)', 'date': 'Date'}
    )
    fig.add_hline(y=80, line_dash="dash", line_color="red", annotation_text="Target (80%)")
    st.plotly_chart(fig, use_container_width=True)
st.subheader("Target vs Actual Performance")
if 'target' in df.columns and 'actual' in df.columns:
    fig = px.bar(
        df,
        x='indicator_name',
        y=['target', 'actual'],
        barmode='group',
        title='Target vs Actual by Indicator',
        labels={'value': 'Values', 'variable': 'Metric'}
    )
    st.plotly_chart(fig, use_container_width=True)
# Data table
with st.expander("View Raw Data"):
    st.dataframe(df)
# Filters
st.sidebar.header("Filters")
status_filter = st.sidebar.multiselect(
    "Status",
    options=df['status'].unique(),
    default=df['status'].unique()
)
if 'category' in df.columns:
    category_filter = st.sidebar.multiselect(
        "Category",
        options=df['category'].unique(),
        default=df['category'].unique()
    )
# Filter data
filtered_df = df[df['status'].isin(status_filter)]
if 'category' in df.columns and 'category_filter' in locals():
    filtered_df = filtered_df[filtered_df['category'].isin(category_filter)]
st.sidebar.markdown("---")
st.sidebar.caption(f"Showing {len(filtered_df)} of {len(df)} records")

# dashboard_dash.py
import dash
from dash import dcc, html, Input, Output
import plotly.express as px
import plotly.graph_objects as go
import pandas as pd
from data_connector import DashboardDataConnector
# Initialize Dash app
app = dash.Dash(__name__, external_stylesheets=['https://codepen.io/chriddyp/pen/bWLwgP.css'])
app.title = "M&E Performance Dashboard"
# Data connector
connector = DashboardDataConnector('excel', 'indicator_data.xlsx', refresh_interval=30)
# App layout
app.layout = html.Div([
    html.H1("M&E Performance Dashboard", style={'textAlign': 'center', 'color': '#1a1a2e'}),
    html.Div(id='last-update', style={'textAlign': 'center', 'color': '#6c757d', 'marginBottom': 20}),
    
    # Key metrics
    html.Div([
        html.Div([
            html.Div(className='card', children=[
                html.H3("Total Indicators"),
                html.H2(id='total-indicators')
            ])
        ], className='four columns'),
        html.Div([
            html.Div(className='card', children=[
                html.H3("On Track"),
                html.H2(id='on-track', style={'color': '#28a745'})
            ])
        ], className='four columns'),
        html.Div([
            html.Div(className='card', children=[
                html.H3("At Risk"),
                html.H2(id='at-risk', style={'color': '#ffc107'})
            ])
        ], className='four columns'),
        html.Div([
            html.Div(className='card', children=[
                html.H3("Off Track"),
                html.H2(id='off-track', style={'color': '#dc3545'})
            ])
        ], className='four columns'),
        html.Div([
            html.Div(className='card', children=[
                html.H3("Avg Achievement"),
                html.H2(id='avg-achievement')
            ])
        ], className='four columns'),
    ], className='row'),
    
    # Charts
    html.Div([
        html.Div([
            html.Div(className='card', children=[
                dcc.Graph(id='status-pie')
            ])
        ], className='six columns'),
        html.Div([
            html.Div(className='card', children=[
                dcc.Graph(id='category-bar')
            ])
        ], className='six columns'),
    ], className='row'),
    
    html.Div([
        html.Div([
            html.Div(className='card', children=[
                dcc.Graph(id='trend-chart')
            ])
        ], className='twelve columns'),
    ], className='row'),
    
    html.Div([
        html.Div([
            html.Div(className='card', children=[
                dcc.Graph(id='target-actual')
            ])
        ], className='twelve columns'),
    ], className='row'),
    
    # Auto-refresh interval
    dcc.Interval(
        id='interval-component',
        interval=30*1000,  # 30 seconds
        n_intervals=0
    ),
], className='container')
# Callbacks for real-time updates
@app.callback(
    [Output('total-indicators', 'children'),
     Output('on-track', 'children'),
     Output('at-risk', 'children'),
     Output('off-track', 'children'),
     Output('avg-achievement', 'children'),
     Output('last-update', 'children'),
     Output('status-pie', 'figure'),
     Output('category-bar', 'figure'),
     Output('trend-chart', 'figure'),
     Output('target-actual', 'figure')],
    [Input('interval-component', 'n_intervals')]
)
def update_dashboard(n):
    # Get latest data
    df = connector.get_data()
    metrics = connector.get_metrics()
    
    # Update metrics
    total = str(metrics['total_indicators'])
    on_track = str(metrics['on_track'])
    at_risk = str(metrics['at_risk'])
    off_track = str(metrics['off_track'])
    avg = f"{metrics['avg_achievement']:.1f}%"
    update_time = f"Last updated: {metrics['last_refresh']}"
    
    # Status pie chart
    status_counts = df['status'].value_counts()
    fig_pie = px.pie(
        values=status_counts.values,
        names=status_counts.index,
        color=status_counts.index,
        color_discrete_map={'on_track': '#28a745', 'at_risk': '#ffc107', 'off_track': '#dc3545'},
        title='Status Distribution'
    )
    
    # Category bar chart
    if 'category' in df.columns:
        category_avg = df.groupby('category')['achievement'].mean().sort_values()
        fig_bar = px.bar(
            x=category_avg.values,
            y=category_avg.index,
            orientation='h',
            color=category_avg.values,
            color_continuous_scale='RdYlGn',
            title='Category Performance',
            labels={'x': 'Avg Achievement (%)', 'y': 'Category'}
        )
    else:
        fig_bar = px.bar()
    
    # Trend chart
    if 'date' in df.columns:
        df_trend = df.groupby('date')['achievement'].mean().reset_index()
        fig_trend = px.line(
            df_trend,
            x='date',
            y='achievement',
            title='Overall Achievement Over Time',
            labels={'achievement': 'Achievement (%)', 'date': 'Date'}
        )
        fig_trend.add_hline(y=80, line_dash="dash", line_color="red", annotation_text="Target (80%)")
    else:
        fig_trend = px.line()
    
    # Target vs Actual
    if 'target' in df.columns and 'actual' in df.columns:
        fig_ta = px.bar(
            df,
            x='indicator_name',
            y=['target', 'actual'],
            barmode='group',
            title='Target vs Actual by Indicator',
            labels={'value': 'Values', 'variable': 'Metric'}
        )
    else:
        fig_ta = px.bar()
    
    return total, on_track, at_risk, off_track, avg, update_time, fig_pie, fig_bar, fig_trend, fig_ta
if __name__ == '__main__':
    app.run_server(debug=True, port=8050)

def check_alerts(df, thresholds=None):
    """Check for indicators that need attention."""
    if thresholds is None:
        thresholds = {
            'off_track': 0,
            'at_risk': 0
        }
    
    alerts = {
        'critical': [],
        'warning': []
    }
    
    # Check off-track indicators
    off_track = df[df['status'] == 'off_track']
    if len(off_track) > thresholds['off_track']:
        for _, row in off_track.iterrows():
            alerts['critical'].append({
                'indicator': row.get('indicator_name', 'Unknown'),
                'achievement': row.get('achievement', 0),
                'message': f"Achievement is {row.get('achievement', 0):.1f}% - Immediate action required"
            })
    
    # Check at-risk indicators
    at_risk = df[df['status'] == 'at_risk']
    if len(at_risk) > thresholds['at_risk']:
        for _, row in at_risk.iterrows():
            alerts['warning'].append({
                'indicator': row.get('indicator_name', 'Unknown'),
                'achievement': row.get('achievement', 0),
                'message': f"Achievement is {row.get('achievement', 0):.1f}% - Needs attention"
            })
    
    return alerts

from datetime import datetime
import json
def export_dashboard_data(df, format='json'):
    """Export dashboard data in various formats."""
    if format == 'json':
        return df.to_json(orient='records', date_format='iso')
    elif format == 'excel':
        filename = f"dashboard_export_{datetime.now().strftime('%Y%m%d')}.xlsx"
        df.to_excel(filename, index=False)
        return filename
    elif format == 'csv':
        filename = f"dashboard_export_{datetime.now().strftime('%Y%m%d')}.csv"
        df.to_csv(filename, index=False)
        return filename
    else:
        raise ValueError(f"Unsupported format: {format}")

class DashboardWidgets:
    """Custom dashboard widgets for M&E metrics."""
    
    @staticmethod
    def status_badge(status):
        """Generate HTML status badge."""
        colors = {
            'on_track': '#28a745',
            'at_risk': '#ffc107',
            'off_track': '#dc3545'
        }
        return f'<span style="background:{colors.get(status, "#6c757d")}; color:white; padding:3px 10px; border-radius:12px; font-size:12px;">{status.replace("_", " ").title()}</span>'
    
    @staticmethod
    def achievement_gauge(achievement):
        """Create HTML gauge widget."""
        color = '#28a745' if achievement >= 80 else '#ffc107' if achievement >= 60 else '#dc3545'
        return f'''
        <div style="text-align:center;">
            <div style="font-size:36px; font-weight:bold; color:{color};>{achievement:.1f}%</div>
            <div style="width:100px; height:10px; background:#e9ecef; border-radius:5px; margin:5px auto;">
                <div style="width:{min(achievement, 100)}%; height:100%; background:{color}; border-radius:5px;"></div>
            </div>
        </div>
        '''
    
    @staticmethod
    def kpi_card(label, value, change=None, icon='📊'):
        """Create KPI card HTML."""
        change_html = f'<small>{change}</small>' if change else ''
        return f'''
        <div style="background:white; padding:15px; border-radius:6px; border:1px solid #e9ecef; text-align:center;">
            <div style="font-size:24px;">{icon}</div>
            <div style="font-size:28px; font-weight:bold; color:#1a1a2e;">{value}</div>
            <div style="color:#6c757d; font-size:14px;">{label}</div>
            {change_html}
        </div>
        '''

# complete_dashboard.py
import pandas as pd
import dash
from dash import dcc, html, Input, Output
import plotly.express as px
from data_connector import DashboardDataConnector
import threading
import time
class CompleteDashboardSystem:
    """Complete dashboard system with real-time updates."""
    
    def __init__(self, data_file='indicator_data.xlsx', port=8050):
        self.data_file = data_file
        self.port = port
        self.connector = DashboardDataConnector('excel', data_file, refresh_interval=30)
        self.app = self._create_app()
    
    def _create_app(self):
        """Create Dash application."""
        app = dash.Dash(__name__)
        app.title = "M&E Real-Time Dashboard"
        
        app.layout = html.Div([
            # Header
            html.Div([
                html.H1("📊 M&E Performance Dashboard", 
                       style={'textAlign': 'center', 'color': '#1a1a2e', 'fontSize': 32}),
                html.Div(id='last-update', 
                        style={'textAlign': 'center', 'color': '#6c757d', 'marginBottom': 20})
            ]),
            
            # KPI Cards
            html.Div([
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("Total Indicators", style={'fontSize': 14}),
                        html.H2(id='total', style={'fontSize': 28, 'fontWeight': 'bold'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("✅ On Track", style={'fontSize': 14}),
                        html.H2(id='on_track', style={'fontSize': 28, 'fontWeight': 'bold', 'color': '#28a745'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("⚡ At Risk", style={'fontSize': 14}),
                        html.H2(id='at_risk', style={'fontSize': 28, 'fontWeight': 'bold', 'color': '#ffc107'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("❌ Off Track", style={'fontSize': 14}),
                        html.H2(id='off_track', style={'fontSize': 28, 'fontWeight': 'bold', 'color': '#dc3545'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("📊 Avg Achievement", style={'fontSize': 14}),
                        html.H2(id='avg_achievement', style={'fontSize': 28, 'fontWeight': 'bold', 'color': '#4a9eff'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
                html.Div([
                    html.Div(className='card', children=[
                        html.H3("🔄 Auto-Refresh", style={'fontSize': 14}),
                        html.Div("30s", style={'fontSize': 28, 'fontWeight': 'bold', 'color': '#1a1a2e'})
                    ], style={'background': 'white', 'padding': 15, 'borderRadius': 6, 
                             'border': '1px solid #e9ecef', 'textAlign': 'center'})
                ], className='two columns'),
            ], className='row', style={'padding': '10px 0'}),
            
            # Charts
            html.Div([
                html.Div([
                    dcc.Graph(id='status_pie')
                ], className='six columns'),
                html.Div([
                    dcc.Graph(id='category_bar')
                ], className='six columns'),
            ], className='row'),
            
            html.Div([
                html.Div([
                    dcc.Graph(id='trend_chart')
                ], className='twelve columns'),
            ], className='row'),
            
            html.Div([
                html.Div([
                    dcc.Graph(id='target_actual')
                ], className='twelve columns'),
            ], className='row'),
            
            # Auto-refresh interval
            dcc.Interval(
                id='interval-component',
                interval=30*1000,
                n_intervals=0
            ),
            
            # CSS
            html.Style("""
                .two.columns { width: 16.666%; float: left; padding: 5px; }
                .six.columns { width: 50%; float: left; padding: 10px; }
                .twelve.columns { width: 100%; float: left; padding: 10px; }
                .card { padding: 15px; background: white; border-radius: 6px; border: 1px solid #e9ecef; }
                .row { display: flex; flex-wrap: wrap; margin: 0 -5px; }
                @media (max-width: 768px) {
                    .two.columns { width: 33.33%; }
                    .six.columns { width: 100%; }
                }
            """)
        ])
        
        self._setup_callbacks(app)
        return app
    
    def _setup_callbacks(self, app):
        """Setup Dash callbacks for real-time updates."""
        @app.callback(
            [Output('total', 'children'),
             Output('on_track', 'children'),
             Output('at_risk', 'children'),
             Output('off_track', 'children'),
             Output('avg_achievement', 'children'),
             Output('last-update', 'children'),
             Output('status_pie', 'figure'),
             Output('category_bar', 'figure'),
             Output('trend_chart', 'figure'),
             Output('target_actual', 'figure')],
            [Input('interval-component', 'n_intervals')]
        )
        def update_dashboard(n):
            df = self.connector.get_data()
            metrics = self.connector.get_metrics()
            
            # Status pie chart
            fig_pie = px.pie(
                values=df['status'].value_counts().values,
                names=df['status'].value_counts().index,
                color=df['status'].value_counts().index,
                color_discrete_map={'on_track': '#28a745', 'at_risk': '#ffc107', 'off_track': '#dc3545'},
                title='Status Distribution'
            )
            
            # Category bar chart
            if 'category' in df.columns:
                category_avg = df.groupby('category')['achievement'].mean().sort_values()
                fig_bar = px.bar(
                    x=category_avg.values,
                    y=category_avg.index,
                    orientation='h',
                    color=category_avg.values,
                    color_continuous_scale='RdYlGn',
                    title='Category Performance',
                    labels={'x': 'Avg Achievement (%)', 'y': 'Category'}
                )
            else:
                fig_bar = px.bar()
            
            # Trend chart
            if 'date' in df.columns:
                df_trend = df.groupby('date')['achievement'].mean().reset_index()
                fig_trend = px.line(
                    df_trend,
                    x='date',
                    y='achievement',
                    title='Overall Achievement Over Time',
                    labels={'achievement': 'Achievement (%)', 'date': 'Date'}
                )
                fig_trend.add_hline(y=80, line_dash="dash", line_color="red", annotation_text="Target (80%)")
            else:
                fig_trend = px.line()
            
            # Target vs Actual
            if 'target' in df.columns and 'actual' in df.columns:
                fig_ta = px.bar(
                    df,
                    x='indicator_name',
                    y=['target', 'actual'],
                    barmode='group',
                    title='Target vs Actual by Indicator',
                    labels={'value': 'Values', 'variable': 'Metric'}
                )
            else:
                fig_ta = px.bar()
            
            return (
                str(metrics['total_indicators']),
                str(metrics['on_track']),
                str(metrics['at_risk']),
                str(metrics['off_track']),
                f"{metrics['avg_achievement']:.1f}%",
                f"Last updated: {metrics['last_refresh']}",
                fig_pie,
                fig_bar,
                fig_trend,
                fig_ta
            )
    
    def run(self, debug=True):
        """Run the dashboard server."""
        print(f"Starting dashboard at http://localhost:{self.port}")
        self.app.run_server(debug=debug, port=self.port)
if __name__ == "__main__":
    # Create sample data
    import random
    dates = ['2024-01-15', '2024-02-15', '2024-03-15', '2024-04-15']
    indicators = [
        ('Children Vaccinated', 5000, 'Health'),
        ('Teachers Trained', 200, 'Education'),
        ('Schools Reached', 100, 'Education'),
        ('Community Events', 50, 'Community'),
        ('Health Centers', 30, 'Health'),
        ('Water Access', 80, 'WASH')
    ]
    
    data = []
    for date in dates:
        for name, target, category in indicators:
            actual = target * (0.7 + random.uniform(0, 0.3))
            data.append({
                'indicator_name': name,
                'target': target,
                'actual': round(actual),
                'date': date,
                'category': category
            })
    
    df = pd.DataFrame(data)
    df.to_excel('indicator_data.xlsx', index=False)
    
    # Start dashboard
    dashboard = CompleteDashboardSystem('indicator_data.xlsx', port=8050)
    dashboard.run()

Master Real-Time Dashboard Integration

The AI Agents for Evaluators Certificate teaches you to build complete M&E solutions including real-time dashboards, automated reporting, and stakeholder management.

Course Features: 32 lectures · Lifetime access · Certificate included · 241 students enrolled

Enroll Now – $249 Lifetime Access

Bundle with AI in M&E course and save 30%