Investment pitch deck creation from financial data

Introduction

Creating an investment pitch deck from raw financial data is a task that typically demands hours of manual work. You extract figures from spreadsheets, format them into charts, write narrative explanations, then arrange everything into a coherent presentation. Each step involves switching between tools, copying and pasting, and checking that the numbers actually match between documents.

The reality of most finance teams is that this process happens weekly or even daily. A founder preparing investor materials might need five iterations. A CFO building quarterly reports needs dozens of decks per year. Every manual handoff introduces delays and creates opportunities for mistakes where a chart gets out of sync with the underlying data.

This is where combining three specialised tools into an automated workflow becomes genuinely valuable. Evalyze-ai handles financial analysis and metric calculation. Finster-ai generates visualisation specifications from those metrics. Preswald-ai assembles everything into a polished, investor-ready presentation file. Wire them together through an orchestration platform and you move from a multi-hour manual process to a fully automated pipeline that runs in minutes.

The Automated Workflow

Choosing Your Orchestration Tool

For this particular workflow, n8n is the best choice. Zapier would work but it's more expensive at scale due to task-based pricing. Make (Integromat) is solid but n8n offers better value for multi-step financial data pipelines because operations are cheaper and execution is faster. Claude Code could work in a pinch but you'd lose the visual workflow monitoring and easier debugging that dedicated orchestration platforms provide.

The Data Flow Architecture

Here's how the pieces fit together:

1. Financial data arrives (CSV, JSON from your accounting system, or a form submission)

2. Evalyze-ai processes the raw numbers, calculates ratios, trends, and metrics

3. Finster-ai receives those analysed metrics and generates chart specifications

4. Preswald-ai takes the charts, metrics, and narrative text and builds the actual presentation

5. The final PDF gets saved to your cloud storage and a notification goes out

Setting Up the n8n Workflow

Start with your trigger. Most commonly this is either a webhook (someone submits financial data via a form) or a scheduled execution (pull data from your accounting API weekly).

Copy
POST /webhook/financial-data-submission
Content-Type: application/json

{
  "company_name": "TechStartup Inc",
  "quarter": "Q3-2024",
  "revenue": 1250000,
  "expenses": 890000,
  "burn_rate": 45000,
  "runway_months": 8,
  "mrr": 125000,
  "customer_count": 142,
  "arr": 1500000
}

In n8n, create a webhook trigger node that accepts this payload. Test it once to confirm the data structure is captured correctly.

Step 1: Data Validation and Enrichment

Before sending data to Evalyze-ai, add a function node in n8n that validates the numbers and handles missing fields. This prevents failed API calls downstream.

Copyconst data = $input.all()[0].json;

const validated = {
  company_name: data.company_name || 'Unnamed Company',
  quarter: data.quarter || new Date().toISOString().slice(0, 7),
  revenue: parseFloat(data.revenue) || 0,
  expenses: parseFloat(data.expenses) || 0,
  burn_rate: parseFloat(data.burn_rate) || 0,
  runway_months: parseFloat(data.runway_months) || 0,
  mrr: parseFloat(data.mrr) || 0,
  customer_count: parseInt(data.customer_count) || 0,
  arr: parseFloat(data.arr) || 0
};

return {
  json: validated
};

This function node cleans up the input, converts strings to numbers, and fills in sensible defaults. It prevents downstream errors from bad data.

Step 2: Call Evalyze-ai for Financial Analysis

Now send the cleaned data to Evalyze-ai. Create an HTTP Request node with these settings:

Copy
Method: POST
URL: https://api.evalyze-ai.com/v1/financial-analysis
Headers:
  Authorization: Bearer YOUR_EVALYZE_API_KEY
  Content-Type: application/json

Body:
{
  "metrics": {
    "revenue": {{ $node["Validate Data"].json.revenue }},
    "expenses": {{ $node["Validate Data"].json.expenses }},
    "burn_rate": {{ $node["Validate Data"].json.burn_rate }},
    "runway_months": {{ $node["Validate Data"].json.runway_months }},
    "mrr": {{ $node["Validate Data"].json.mrr }},
    "customer_count": {{ $node["Validate Data"].json.customer_count }},
    "arr": {{ $node["Validate Data"].json.arr }}
  },
  "analysis_type": "investor_pitch",
  "include_trends": true,
  "include_benchmarks": true
}

Evalyze-ai will return enriched financial analysis including calculated ratios, year-over-year comparisons, and benchmark data. Save the full response into a variable for the next step.

The response typically looks like this:

Copy{
  "metrics": {
    "gross_margin": 0.289,
    "burn_multiple": 1.2,
    "months_to_break_even": 14,
    "customer_acquisition_cost": 8802,
    "lifetime_value": 125000,
    "burn_rate_trend": "declining",
    "revenue_growth_rate": 0.15
  },
  "insights": [
    "Runway is improving month-over-month",
    "CAC is within industry norms for B2B SaaS"
  ],
  "risk_factors": [
    "Burn rate still exceeds positive unit economics threshold"
  ]
}

Step 3: Generate Visualisation Specifications with Finster-ai

Create another HTTP Request node pointing to Finster-ai. This tool doesn't generate images; it generates the specifications that Preswald-ai will use to create actual charts.

Copy
Method: POST
URL: https://api.finster-ai.com/v1/chart-specifications
Headers:
  Authorization: Bearer YOUR_FINSTER_API_KEY
  Content-Type: application/json

Body:
{
  "data_source": "evalyze",
  "metrics": {{ JSON.stringify($node["Evalyze Analysis"].json.metrics) }},
  "chart_types": [
    "revenue_expense_waterfall",
    "runway_projection_line",
    "unit_economics_gauge",
    "customer_metrics_dashboard"
  ],
  "style": "investor_pitch",
  "colour_scheme": "professional_blue"
}

Finster-ai returns chart specifications in a format that Preswald-ai understands. This is the critical integration point that prevents manual chart recreation.

Copy{
  "charts": [
    {
      "id": "chart_revenue_breakdown",
      "type": "waterfall",
      "title": "Revenue vs Expenses",
      "data_points": [
        { "label": "Revenue", "value": 1250000, "colour": "green" },
        { "label": "Expenses", "value": -890000, "colour": "red" },
        { "label": "Profit", "value": 360000, "colour": "blue" }
      ]
    },
    {
      "id": "chart_runway",
      "type": "line",
      "title": "Projected Runway",
      "x_axis": "months",
      "data_series": [
        { "name": "Cash Balance", "values": [2400000, 2355000, 2310000, ...] }
      ]
    }
  ],
  "narrative_prompts": {
    "opening": "Focus on runway improvement and unit economics",
    "closing": "Emphasise market opportunity and path to profitability"
  ]
}

Step 4: Assemble the Presentation with Preswald-ai

This is where everything comes together. Create the final HTTP Request node:

Copy
Method: POST
URL: https://api.preswald-ai.com/v1/presentations/create
Headers:
  Authorization: Bearer YOUR_PRESWALD_API_KEY
  Content-Type: application/json

Body:
{
  "presentation_type": "investor_pitch",
  "company_name": {{ $node["Validate Data"].json.company_name }},
  "slides": [
    {
      "type": "title_slide",
      "content": {
        "company_name": {{ $node["Validate Data"].json.company_name }},
        "tagline": "Financial Overview",
        "date": "{{ new Date().toISOString().split('T')[0] }}"
      }
    },
    {
      "type": "charts",
      "content": {{ JSON.stringify($node["Finster Specs"].json.charts) }}
    },
    {
      "type": "metrics_summary",
      "content": {
        "metrics": {{ JSON.stringify($node["Evalyze Analysis"].json.metrics) }},
        "insights": {{ JSON.stringify($node["Evalyze Analysis"].json.insights) }},
        "risks": {{ JSON.stringify($node["Evalyze Analysis"].json.risk_factors) }}
      }
    },
    {
      "type": "closing_slide",
      "content": {
        "headline": "Ready to Scale",
        "call_to_action": "Let's discuss the opportunity"
      }
    }
  ],
  "output_format": "pdf",
  "include_speaker_notes": true
}

Preswald-ai assembles these slides into a professionally formatted presentation. It handles typography, spacing, and visual hierarchy automatically.

Step 5: Save and Notify

Create a final set of nodes to handle the output:

1. A Google Drive (or OneDrive) upload node that saves the PDF with a descriptive filename:

Copy
File name: {{ $node["Validate Data"].json.company_name }}_Pitch_Deck_{{ $node["Validate Data"].json.quarter }}_{{ new Date().toISOString().slice(0, 10) }}.pdf

2. An email notification node that sends the PDF to your stakeholders:

Copy
To: {{ $env.RECIPIENT_EMAIL }}
Subject: Pitch Deck Ready: {{ $node["Validate Data"].json.company_name }}
Body: Your investment pitch deck has been generated and is ready for review. See attached.

3. Optionally, a Slack notification for immediate awareness:

Copy
Channel: #finance
Message: :chart_with_upwards_trend: Pitch deck generated for {{ $node["Validate Data"].json.company_name }} - {{ $node["Validate Data"].json.quarter }}. View it here: [link from Google Drive]

The Manual Alternative

If you need more control over specific slides or want to review intermediate outputs before proceeding, you can build a semi-automated workflow instead. After Evalyze-ai completes its analysis, insert a manual approval step. A team member reviews the metrics and insights, makes adjustments if necessary, then manually triggers the Finster-ai step. This adds 10-15 minutes of human review time but prevents automated decisions that might misrepresent your financials.

Some teams prefer this approach because it creates an audit trail and ensures compliance sign-off, particularly for external investor communications. The downside is that you lose the speed advantage. If you're creating dozens of decks annually, manual checkpoints become a bottleneck.

Another option is to use Preswald-ai in review mode rather than auto-publish mode. It generates a draft presentation, stores it temporarily, and sends you a link for review. You approve, request changes, or accept as-is before it gets saved to your final storage location. This adds a quality gate without requiring you to rebuild the entire workflow.

Pro Tips

Rate Limits and Throttling

All three APIs have rate limits. Evalyze-ai allows 100 requests per minute on their standard plan. Finster-ai throttles at 50 per minute. Preswald-ai has a 30 requests per minute limit. If you're processing multiple decks in parallel, you'll hit these quickly. Add a delay node between requests (2-3 seconds minimum) and implement exponential backoff for retries. In n8n, use the "Wait" node set to 3 seconds between API calls.

Copy// Exponential backoff retry logic
let retries = 0;
const maxRetries = 3;
let success = false;
let response;

while (retries < maxRetries && !success) {
  try {
    response = await makeRequest();
    success = true;
  } catch (error) {
    if (error.status === 429) {
      const delay = Math.pow(2, retries) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
      retries++;
    } else {
      throw error;
    }
  }
}

Error Handling for Missing Data

Financial data from different sources is inconsistent. Some APIs provide trailing twelve-month revenue; others provide quarterly. Some omit burn rate entirely. Build validation into your workflow that identifies missing required fields and either substitutes reasonable estimates or halts the workflow with a descriptive error. Send yourself a message before Preswald-ai tries to create a slide with null values, which will produce a broken presentation.

Cost Optimisation Through Batching

Rather than creating decks on-demand, batch them. Run the workflow once per week for all companies in your portfolio instead of triggering it five times daily. This reduces API calls significantly. Schedule it for Wednesday morning so all stakeholders have fresh decks mid-week. You'll save roughly 40% on API costs through batching.

Reusing Evaluated Metrics

Cache the output from Evalyze-ai for 24 hours. If someone requests a second deck with identical underlying financial data, pull from the cache rather than re-querying the API. Implement this with n8n's built-in caching or by storing results in a lightweight database like Firebase. This is especially useful when founders request multiple versions of the same deck with different narrative angles.

Monitoring Data Quality

Add logging to every API call. Log the input, the output, and any transformation steps in between. When a generated deck looks wrong, you need to know which tool failed or produced unexpected output. Use n8n's built-in error tracking or send all logs to a service like Loggly. Include the source financial data in your logs so you can reproduce issues.

Cost Breakdown

The self-hosted n8n option is significantly cheaper but requires you to maintain a server. For most small teams, the Cloud Pro tier is worth the cost for uptime guarantees and automatic backups. If you're processing more than 100 decks monthly, costs scale linearly with API usage, so investigate Evalyze-ai's higher tiers which offer volume discounts.

This workflow eliminates roughly eight hours per week of manual work for a typical finance team processing 10-15 pitch decks monthly. At an average salary cost of £50 per hour, that's £400 in labour savings per week, or £1,600 monthly. Even at the upper end of the cost breakdown (£760), your ROI is positive within the first week.