Building a Weekly Metrics Deck With the Preso API and Cron

The Problem: Weekly Metrics Decks That Eat Your Afternoon

Every Monday morning, someone on your team opens a spreadsheet full of last week's numbers. They know what the story is. They know which metrics moved, which stayed flat, and what it means for the business. But instead of sharing that insight in five minutes, they spend the next three hours fighting PowerPoint alignment, copying charts from Google Sheets, resizing text boxes, and trying to remember where your brand colors live.

By the time the deck is done, it looks generic. The data is stale. And next week, someone does it all over again.

There is a better way. If your metrics live in a data source you can reach from a script, you can automate the entire journey from raw numbers to a finished, on-brand presentation deck. No manual design work. No copy-paste errors. No three-hour afternoons lost to formatting.

This guide walks you through building a system that pulls your weekly metrics from a data source, feeds them into the Preso API, and generates a polished, branded deck every single week on a schedule. By the end, you will have a cron job that does the work for you.

Prerequisites: What You Need Before You Start

Before you build your automated metrics deck pipeline, make sure you have the following in place:

Access and Credentials

You will need API access to Preso. Contact the Preso team to request API credentials; they will provide you with an API key and endpoint URL. Store these credentials securely, never in plain text in your scripts or version control.

You will also need access to the data source where your metrics live. This could be a Google Sheets document, a Salesforce instance, a HubSpot account, a data warehouse, or any system that exposes an API or allows you to export structured data. Make sure you have read access and, if needed, service account credentials to authenticate programmatically.

Technical Foundations

You should be comfortable with basic command-line scripting. This guide uses Python and bash, but the concepts apply to any language. You will write a script that fetches your metrics, formats them into a prompt or data structure, and makes an API call to Preso.

You will also need a Unix-like environment (Linux, macOS, or Windows Subsystem for Linux) to run cron jobs. If you are on Windows and not using WSL, you can use Task Scheduler instead, but the scheduling syntax differs.

Lastly, you should have a way to store and retrieve the generated deck. This could be a shared folder, a cloud storage bucket, an email inbox, or a Slack channel. We will cover a few options as we go.

Brand Kit Ready

Before you generate decks, set up your brand kit in Preso. Upload your logo, define your color palette, choose your fonts, and set your brand voice. The API will apply these rules to every deck it generates, so you never have to worry about off-brand slides.

Step 1: Design Your Metrics Data Structure

The first step is to decide what data goes into your weekly deck and how you will fetch it. You need a clear, structured format that your script can read and pass to Preso.

Define Your Metrics

Start by listing the metrics that matter for your weekly report. For a SaaS company, this might be monthly recurring revenue (MRR), customer churn, new signups, and activation rate. For a marketing team, it could be campaign impressions, click-through rate, cost per acquisition, and pipeline influence. For a sales team, it might be pipeline value, deals closed, average deal size, and win rate.

For each metric, note:

• The metric name and definition
• The data source (Google Sheets, Salesforce, HubSpot, your database, etc.)
• How to fetch it (API call, SQL query, sheet range, etc.)
• The time period (week-over-week, month-over-month, or absolute number)
• Any comparison you want to highlight (versus last week, versus target, versus last year)

Keep the list focused. A strong weekly deck tells one story with five to eight key metrics, not a sprawling dashboard with thirty numbers.

Structure the Data

Your script will fetch these metrics and organize them into a format that Preso can understand. The simplest approach is a JSON object or a Python dictionary that looks like this:

{
  "week_ending": "2026-07-26",
  "metrics": [
    {
      "name": "MRR",
      "value": 145000,
      "change": "+8.3%",
      "vs": "last week"
    },
    {
      "name": "New Signups",
      "value": 287,
      "change": "+12%",
      "vs": "last week"
    },
    {
      "name": "Churn Rate",
      "value": "2.1%",
      "change": "-0.3pp",
      "vs": "last week"
    }
  ],
  "highlights": "MRR crossed 145k. Churn ticked down. Pipeline grew 18%.",
  "risks": "CAC up 5% week-over-week. Watch for seasonal softness in August."
}

This structure makes it easy to pass data into your Preso API call. You will transform this JSON into a narrative prompt that Preso can turn into slides.

Step 2: Write a Script to Fetch Your Metrics

Now you will write the script that actually pulls the numbers. This is the engine of your automation.

Choose Your Data Source

The approach depends on where your metrics live. Here are the most common patterns:

Google Sheets: If your metrics are in a Google Sheet, use the Google Sheets API to read the data. You will need to create a service account and share the sheet with that account's email address.

Salesforce or HubSpot: Both platforms expose REST APIs. For Salesforce, you can query records and aggregate metrics using SOQL. For HubSpot, you can pull deal, contact, and company data and calculate your metrics from there.

Data Warehouse or Database: If your metrics live in a PostgreSQL, Snowflake, BigQuery, or other warehouse, write a SQL query that calculates your weekly metrics and returns the results as a table or JSON.

Third-Party Data Pipeline: Tools like Airbyte can run scheduled ELT jobs that populate a database or data lake with your metrics, which your script then reads.

Write the Fetch Function

Here is a Python example that fetches metrics from a Google Sheet:

import os
from google.oauth2 import service_account
from google.auth.transport.requests import Request
from googleapiclient.discovery import build
from datetime import datetime, timedelta
 
def fetch_metrics_from_sheets():
    # Load service account credentials
    creds = service_account.Credentials.from_service_account_file(
        'path/to/service_account.json',
        scopes=['https://www.googleapis.com/auth/spreadsheets.readonly']
    )
    
    service = build('sheets', 'v4', credentials=creds)
    
    # Read the metrics from your sheet
    sheet_id = 'your-sheet-id'
    result = service.spreadsheets().values().get(
        spreadsheetId=sheet_id,
        range='Metrics!A1:C10'
    ).execute()
    
    values = result.get('values', [])
    
    # Parse the values into a metrics dictionary
    metrics = []
    for row in values[1:]:  # Skip header
        metrics.append({
            'name': row[0],
            'value': row[1],
            'change': row[2]
        })
    
    return metrics

If you are pulling from a database, your function might look like:

import psycopg2
from datetime import datetime, timedelta
 
def fetch_metrics_from_database():
    conn = psycopg2.connect(
        host='your-db-host',
        database='your-db',
        user='your-user',
        password='your-password'
    )
    
    cursor = conn.cursor()
    
    # Calculate week-over-week metrics
    query = """
    SELECT
        'MRR' as metric_name,
        SUM(monthly_value) as current_value,
        LAG(SUM(monthly_value)) OVER (ORDER BY week) as previous_value
    FROM revenue
    WHERE week >= CURRENT_DATE - INTERVAL '2 weeks'
    GROUP BY week
    ORDER BY week DESC
    LIMIT 1
    """
    
    cursor.execute(query)
    row = cursor.fetchone()
    
    current = row[1]
    previous = row[2]
    change_pct = ((current - previous) / previous * 100) if previous else 0
    
    metrics = [{
        'name': 'MRR',
        'value': current,
        'change': f"+{change_pct:.1f}%" if change_pct > 0 else f"{change_pct:.1f}%"
    }]
    
    cursor.close()
    conn.close()
    
    return metrics

The key is that your fetch function returns a clean, structured list of metrics that you can pass forward.

Step 3: Build the Preso API Request

Once you have your metrics, you need to turn them into a prompt that Preso understands and make an API call to generate the deck.

Craft the Narrative Prompt

The Preso API accepts a text description of what you want the deck to show. Instead of feeding raw JSON, write a clear narrative that tells the story of your metrics. This is the same way you would describe a deck to a designer.

Here is an example prompt:

Create a weekly metrics deck for the week ending July 26, 2026. 

Key metrics:
- MRR: $145,000, up 8.3% from last week
- New Signups: 287, up 12% from last week
- Churn Rate: 2.1%, down 0.3 percentage points from last week
- Customer Acquisition Cost: $487, up 5% from last week
- Pipeline Value: $2.3M, up 18% from last week

Highlights: MRR crossed 145k for the first time. Churn ticked down despite seasonal headwinds. Pipeline grew significantly thanks to three new enterprise conversations.

Risks: CAC is trending up. We need to tighten targeting to bring it back down. Watch for seasonal softness in August.

Design the deck with four slides:
1. Title slide with the week ending date and headline: "Strong Week: MRR Grows 8.3%, Churn Drops"
2. Key metrics overview with the five metrics listed above, color-coded green for positive, red for negative
3. Detailed narrative explaining the highlights and risks
4. Next week priorities and action items

Write this prompt in your script by combining the fetched metrics with a template:

def build_prompt(metrics, highlights, risks):
    prompt = f"""
Create a weekly metrics deck for the week ending {datetime.now().strftime('%B %d, %Y')}.
 
Key metrics:
"""
    
    for metric in metrics:
        prompt += f"- {metric['name']}: {metric['value']}, {metric['change']} from last week\n"
    
    prompt += f"""
 
Highlights: {highlights}
 
Risks: {risks}
 
Design with a title slide, metrics overview, narrative analysis, and next steps.
Use the brand kit colors and fonts. Make it ready to present.
"""
    
    return prompt

Make the API Call

Now you call the Preso API with your prompt. Here is how to do it in Python:

import requests
import json
 
def generate_deck_with_preso(prompt, brand_kit_id):
    api_key = os.getenv('PRESO_API_KEY')
    api_url = 'https://api.trypreso.com/v1/decks/generate'
    
    headers = {
        'Authorization': f'Bearer {api_key}',
        'Content-Type': 'application/json'
    }
    
    payload = {
        'prompt': prompt,
        'brand_kit_id': brand_kit_id,
        'format': 'json',  # Returns deck data as JSON
        'output_format': 'pptx'  # Also generate downloadable PPTX
    }
    
    response = requests.post(api_url, json=payload, headers=headers)
    
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code}")
        print(response.text)
        return None

The API returns a deck object with slides, content, and metadata. You can then download it, save it, or share it.

Step 4: Handle the Output and Distribution

Once Preso generates your deck, you need to do something with it. This could mean saving it to cloud storage, emailing it, posting it to Slack, or storing it in your presentation library.

Save to Cloud Storage

The simplest approach is to save the deck to Google Drive, AWS S3, or another cloud storage service. Here is how to save to Google Drive:

from google.oauth2 import service_account
from googleapiclient.discovery import build
import io
 
def save_deck_to_drive(deck_pptx_bytes, week_ending):
    creds = service_account.Credentials.from_service_account_file(
        'path/to/service_account.json',
        scopes=['https://www.googleapis.com/auth/drive']
    )
    
    service = build('drive', 'v3', credentials=creds)
    
    file_metadata = {
        'name': f'Weekly Metrics - {week_ending}.pptx',
        'parents': ['your-folder-id'],
        'mimeType': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
    }
    
    file = service.files().create(
        body=file_metadata,
        media_body=io.BytesIO(deck_pptx_bytes),
        fields='id'
    ).execute()
    
    return file.get('id')

Email the Deck

You can also email the deck to stakeholders automatically:

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders
 
def email_deck(deck_pptx_bytes, recipients, week_ending):
    sender_email = os.getenv('SENDER_EMAIL')
    sender_password = os.getenv('SENDER_PASSWORD')
    
    message = MIMEMultipart()
    message['From'] = sender_email
    message['To'] = ', '.join(recipients)
    message['Subject'] = f'Weekly Metrics Deck - {week_ending}'
    
    body = "Your weekly metrics deck is attached. Ready to present."
    message.attach(MIMEText(body, 'plain'))
    
    # Attach the PPTX
    attachment = MIMEBase('application', 'octet-stream')
    attachment.set_payload(deck_pptx_bytes)
    encoders.encode_base64(attachment)
    attachment.add_header('Content-Disposition', f'attachment; filename= {week_ending}_metrics.pptx')
    message.attach(attachment)
    
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, recipients, message.as_string())

Post to Slack

If your team uses Slack, you can post the deck there:

from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
 
def post_deck_to_slack(deck_pptx_bytes, channel_id, week_ending):
    client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
    
    try:
        response = client.files_upload_v2(
            channel=channel_id,
            file=('Weekly_Metrics.pptx', deck_pptx_bytes),
            title=f'Weekly Metrics - {week_ending}',
            initial_comment='Your metrics deck is ready. No manual design work needed.'
        )
    except SlackApiError as e:
        print(f"Error posting to Slack: {e}")

Choose the distribution method that fits your workflow. Many teams use a combination: save to Drive for archival, email to executives, and post to Slack for the team.

Step 5: Schedule the Script With Cron

Now comes the automation magic. You will use cron to run your script on a schedule, so the deck generates every week without any manual intervention.

Write the Master Script

First, combine all the pieces into one master Python script:

#!/usr/bin/env python3
import os
import sys
from datetime import datetime
 
# Import the functions you defined above
from metrics_fetcher import fetch_metrics_from_sheets
from preso_client import generate_deck_with_preso
from distribution import save_deck_to_drive, email_deck, post_deck_to_slack
 
def main():
    # Fetch metrics
    metrics = fetch_metrics_from_sheets()
    if not metrics:
        print("Failed to fetch metrics")
        sys.exit(1)
    
    # Build prompt
    highlights = "MRR crossed 145k. Churn ticked down. Pipeline grew 18%."
    risks = "CAC up 5% week-over-week. Watch for seasonal softness in August."
    prompt = build_prompt(metrics, highlights, risks)
    
    # Generate deck
    brand_kit_id = os.getenv('PRESO_BRAND_KIT_ID')
    deck = generate_deck_with_preso(prompt, brand_kit_id)
    if not deck:
        print("Failed to generate deck")
        sys.exit(1)
    
    # Get the PPTX bytes
    deck_pptx_bytes = deck.get('pptx_bytes')
    week_ending = datetime.now().strftime('%Y-%m-%d')
    
    # Distribute
    save_deck_to_drive(deck_pptx_bytes, week_ending)
    email_deck(deck_pptx_bytes, ['[email protected]'], week_ending)
    post_deck_to_slack(deck_pptx_bytes, 'C12345678', week_ending)
    
    print(f"Deck generated and distributed for {week_ending}")
 
if __name__ == '__main__':
    main()

Make the script executable:

chmod +x /path/to/weekly_metrics_deck.py

Set Up Environment Variables

Your script needs API keys and credentials. Store these as environment variables, never hardcoded in the script:

export PRESO_API_KEY='your-api-key'
export PRESO_BRAND_KIT_ID='your-brand-kit-id'
export SENDER_EMAIL='[email protected]'
export SENDER_PASSWORD='your-app-password'
export SLACK_BOT_TOKEN='xoxb-your-token'

You can store these in a .env file and load them with python-dotenv:

from dotenv import load_dotenv
load_dotenv()

Create the Cron Job

Now open your cron editor:

crontab -e

Add a line to run your script every Friday at 5 PM (or whenever you want your weekly deck):

0 17 * * 5 /usr/bin/python3 /path/to/weekly_metrics_deck.py >> /var/log/metrics_deck.log 2>&1

Breaking down the cron syntax:

• 0: minute (0)
• 17: hour (5 PM in 24-hour format)
• *: day of month (any)
• *: month (any)
• 5: day of week (Friday, 0=Sunday)
• /usr/bin/python3 /path/to/weekly_metrics_deck.py: the command to run
• >> /var/log/metrics_deck.log 2>&1: log output to a file

For more complex schedules, refer to the official cron documentation.

Test the Cron Job

Before you rely on cron, test it manually:

/usr/bin/python3 /path/to/weekly_metrics_deck.py

Check the log file:

tail -f /var/log/metrics_deck.log

Make sure the deck generates, saves, and distributes without errors.

Step 6: Monitor and Iterate

Once your cron job is running, you need to monitor it and refine it over time.

Check Logs Regularly

Cron jobs run silently in the background. If something breaks, you will only know if you check the logs. Set a reminder to review /var/log/metrics_deck.log weekly:

grep -i error /var/log/metrics_deck.log

Handle API Failures Gracefully

Networks fail. APIs go down. Your metrics source might be temporarily unavailable. Add retry logic to your script:

import time
 
def retry_api_call(func, max_retries=3, backoff=2):
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt < max_retries - 1:
                wait_time = backoff ** attempt
                print(f"Attempt {attempt + 1} failed. Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                print(f"All {max_retries} attempts failed.")
                raise
 
# Use it like this:
metrics = retry_api_call(fetch_metrics_from_sheets)

Update Your Metrics Over Time

Your business changes. New metrics become important. Old ones become noise. Every month or quarter, review which metrics are in your deck and update them. The beauty of this system is that you can change the metrics in your data source, update your fetch function, and the next deck automatically reflects the new story.

Refine the Narrative

As you generate more decks, you will learn what narrative works best. Maybe you need to highlight risks more prominently. Maybe you want to add a forward-looking section. Update your prompt template to evolve with your needs.

Pro Tips and Warnings

Pro Tip: Use Preso's Brand Kit to Enforce Consistency

Every deck your system generates will inherit your brand kit colors, fonts, and logo. This means you never have to worry about off-brand slides, even when the API generates decks at scale. Set your brand rules once, and they apply to every deck forever.

Pro Tip: Combine Multiple Data Sources

Your metrics might live in different places. One team tracks revenue in Salesforce, another tracks product metrics in your data warehouse, and a third maintains campaign data in HubSpot. Your fetch script can call all three APIs, aggregate the results, and feed them into a single narrative. This gives you a unified weekly story across the entire business.

Pro Tip: Use GitHub Actions or Prefect for Reliability

If you want more control and observability, consider running your script on GitHub Actions (if your code is on GitHub) or Prefect, a workflow orchestration platform. Both offer built-in scheduling, error handling, and alerting, so you know immediately if something breaks.

Warning: Secure Your Credentials

Your script needs API keys, database passwords, and service account files. Never commit these to version control. Never hardcode them in your script. Use environment variables, a secrets manager like AWS Secrets Manager, or a .env file that is in your .gitignore. If a credential is ever exposed, rotate it immediately.

Warning: Test Your Data Source Connectivity

Before you set up cron, make sure your script can reliably connect to your data source from the machine where cron will run. If you are running cron on a server, test the connection from that server. Network policies, firewalls, and IP allowlists can block connections in ways that are hard to debug after the fact.

Warning: Monitor Your API Quota

Each API call to Preso, Google Sheets, Salesforce, or your database counts against your quota. If you generate a deck every week, that is 52 decks a year. If you later add a daily deck, that is 365. Make sure you have enough API quota to sustain your schedule, and monitor usage so you do not get surprised by rate limits.

Putting It All Together: A Complete Example

Here is a complete, working example that ties everything together. This script fetches metrics from a Google Sheet, generates a deck with Preso, and emails it to your team.

#!/usr/bin/env python3
 
import os
import sys
import json
import requests
import smtplib
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders
from google.oauth2 import service_account
from googleapiclient.discovery import build
from dotenv import load_dotenv
 
load_dotenv()
 
def fetch_metrics():
    """Fetch metrics from Google Sheets."""
    creds = service_account.Credentials.from_service_account_file(
        os.getenv('GOOGLE_CREDS_PATH'),
        scopes=['https://www.googleapis.com/auth/spreadsheets.readonly']
    )
    
    service = build('sheets', 'v4', credentials=creds)
    result = service.spreadsheets().values().get(
        spreadsheetId=os.getenv('SHEET_ID'),
        range='Metrics!A2:C10'
    ).execute()
    
    metrics = []
    for row in result.get('values', []):
        metrics.append({
            'name': row[0],
            'value': row[1],
            'change': row[2]
        })
    
    return metrics
 
def build_prompt(metrics):
    """Build a narrative prompt from metrics."""
    metric_text = '\n'.join([f"- {m['name']}: {m['value']}, {m['change']} from last week" for m in metrics])
    
    prompt = f"""
Create a professional weekly metrics deck for the week ending {datetime.now().strftime('%B %d, %Y')}.
 
Key metrics:
{metric_text}
 
Highlights: Strong growth across the board. MRR up, churn down, pipeline solid.
Risks: CAC trending up. Monitor acquisition efficiency.
 
Design with a title slide, metrics overview, and narrative analysis. Use the brand kit.
"""
    
    return prompt
 
def generate_deck(prompt):
    """Call the Preso API to generate a deck."""
    api_key = os.getenv('PRESO_API_KEY')
    api_url = 'https://api.trypreso.com/v1/decks/generate'
    
    headers = {
        'Authorization': f'Bearer {api_key}',
        'Content-Type': 'application/json'
    }
    
    payload = {
        'prompt': prompt,
        'brand_kit_id': os.getenv('PRESO_BRAND_KIT_ID'),
        'output_format': 'pptx'
    }
    
    response = requests.post(api_url, json=payload, headers=headers, timeout=60)
    
    if response.status_code == 200:
        return response.content  # PPTX bytes
    else:
        raise Exception(f"API error: {response.status_code} {response.text}")
 
def email_deck(deck_bytes, week_ending):
    """Email the deck to the team."""
    sender_email = os.getenv('SENDER_EMAIL')
    sender_password = os.getenv('SENDER_PASSWORD')
    recipients = os.getenv('RECIPIENTS').split(',')
    
    message = MIMEMultipart()
    message['From'] = sender_email
    message['To'] = ', '.join(recipients)
    message['Subject'] = f'Weekly Metrics Deck - {week_ending}'
    
    body = "Your weekly metrics deck is ready. No manual work required."
    message.attach(MIMEText(body, 'plain'))
    
    attachment = MIMEBase('application', 'octet-stream')
    attachment.set_payload(deck_bytes)
    encoders.encode_base64(attachment)
    attachment.add_header('Content-Disposition', f'attachment; filename=metrics_{week_ending}.pptx')
    message.attach(attachment)
    
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, recipients, message.as_string())
    
    print(f"Deck emailed to {', '.join(recipients)}")
 
def main():
    try:
        print("Fetching metrics...")
        metrics = fetch_metrics()
        
        print("Building prompt...")
        prompt = build_prompt(metrics)
        
        print("Generating deck with Preso...")
        deck_bytes = generate_deck(prompt)
        
        week_ending = datetime.now().strftime('%Y-%m-%d')
        print(f"Emailing deck for {week_ending}...")
        email_deck(deck_bytes, week_ending)
        
        print("Success! Deck generated and distributed.")
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)
 
if __name__ == '__main__':
    main()

Store your credentials in a .env file:

PRESO_API_KEY=your-api-key
PRESO_BRAND_KIT_ID=your-brand-kit-id
GOOGLE_CREDS_PATH=/path/to/service_account.json
SHEET_ID=your-sheet-id
[email protected]
SENDER_PASSWORD=your-app-password
[email protected],[email protected]

Add to cron:

0 17 * * 5 /usr/bin/python3 /path/to/weekly_metrics_deck.py >> /var/log/metrics_deck.log 2>&1

Test it:

/usr/bin/python3 /path/to/weekly_metrics_deck.py

You now have a fully automated weekly metrics deck system.

Advanced: Headless Decks With the Preso API

If you want even more control, you can use the Preso API to generate decks programmatically and integrate them directly into your product or workflow. This is called headless presentation generation.

Instead of downloading a PPTX file, you can use the Preso MCP server to generate decks as JSON data that you can then transform, embed, or distribute however you want. This is especially powerful if you are building a SaaS product that needs to generate reports, proposals, or dashboards on demand.

For example, if you are building a sales platform, you could use the Preso API to generate a deal summary deck every time a prospect reaches a certain stage. If you are building a marketing analytics tool, you could generate campaign performance decks automatically.

The Preso API documentation covers all the details, but the core idea is the same: describe what you want, and Preso generates it.

Conclusion: From Data to Deck in Minutes

You have now built a system that turns raw metrics into a polished, on-brand presentation deck every single week, with zero manual design work. No more afternoons lost to PowerPoint. No more generic templates. No more copy-paste errors.

Here is what you have accomplished:

1. Designed a metrics data structure that captures the story of your business
2. Written a script that fetches those metrics from your data source
3. Built a prompt that turns those metrics into a narrative
4. Called the Preso API to generate a finished deck
5. Distributed the deck to your team via email, Slack, or cloud storage
6. Scheduled the entire workflow with cron to run automatically every week

The system is flexible. You can change your metrics, update your narrative template, add new data sources, or adjust your distribution method without touching the core automation. And because every deck inherits your brand kit, you never have to worry about consistency.

If you want to go further, explore the Preso API for headless deck generation, or use Preso integrations to pull live data directly from Salesforce, HubSpot, or your other tools.

The metrics are already there. The story is already clear. Now let Preso tell it for you, every single week, automatically.

Ready to build your first automated metrics deck? Start with Preso and describe your idea in plain English. We will design the deck for you.