Academic conference presentation deck from research paper in 30 minutes

Introduction

You've just finished writing your research paper. It's solid work, months of research distilled into 8,000 words. Now you need to present it at a conference in four weeks, and you're starting from scratch with the presentation deck.

Most researchers face this same bottleneck: converting a dense PDF into a visually coherent presentation takes hours of manual work. You read through the paper, identify key findings, sketch diagrams in your head, create slides, hunt for icons, adjust layouts. The work is tedious and repetitive, yet critical to getting your message across.

What if you could have a working conference presentation deck, complete with diagrams and infographics, in 30 minutes? This workflow does exactly that by chaining together three AI tools and eliminating every manual handoff. Your research paper PDF becomes the single input; your presentation deck is the output.

The Automated Workflow

We'll build this using Claude Code as the orchestration engine. Claude Code works well here because it can make API calls, handle file uploads, and coordinate between tools without needing a separate workflow platform. If you prefer a dedicated orchestration tool, we'll show alternatives at the end.

Tool Overview and Prerequisites

Before we start, ensure you have access to these tools:

• chat-with-pdf-by-copilotus: Extracts structured insights from your research paper.

• diagram: Generates flowcharts, process diagrams, and conceptual visualisations from text descriptions.

• text2infographic: Converts statistics and key points into visual infographics.

You'll also need a Claude API key and a way to interact with these APIs. Most of these tools expose REST endpoints; some require OAuth. Verify current authentication details in each tool's documentation before starting.

Step 1:

Extract Key Insights from Your PDF

The first step is to feed your research paper into chat-with-pdf-by-copilotus and extract the core findings, methodology, and conclusions in a structured format.

What happens: You upload your PDF and ask the tool to generate a JSON output containing the paper's title, abstract, key findings (in bullet points), methodology, and conclusions. This becomes the backbone of your presentation.

API Call:

Copy
POST https://api.copilotus.chat/v1/chat
Content-Type: application/json
Authorization: Bearer YOUR_COPILOTUS_API_KEY

{
  "document_url": "https://your-storage.com/research-paper.pdf",
  "query": "Extract the following in JSON format: title, abstract, 5 key findings as bullet points, methodology summary (2-3 sentences), and main conclusions. Make findings concrete and presentation-ready.",
  "response_format": "json"
}

The response will look like this:

Copy{
  "title": "Machine Learning Approaches to Early Disease Detection",
  "abstract": "This paper explores...",
  "key_findings": [
    "Model achieved 94% accuracy in early diagnosis",
    "Reduced diagnostic time by 40% compared to traditional methods",
    "False positive rate below 2% across all demographic groups"
  ],
  "methodology": "We employed a supervised learning approach using a dataset of 50,000 patient records...",
  "conclusions": "Our findings suggest that ML-based approaches can significantly improve clinical efficiency..."
}

Save this JSON; you'll feed it into the next step.

Step 2:

Generate Diagrams from Methodology and Results

Now you have structured data. The next step is to ask the diagram tool to create visual representations of your methodology and key results. Diagrams are the backbone of any good presentation; they replace walls of text.

What happens: You provide a text description of your methodology and findings, and the diagram tool outputs SVG or PNG files ready for your slides. Request multiple diagram types: a flowchart for methodology, a comparative diagram for results.

API Call for Methodology Diagram:

Copy
POST https://api.diagram.cloud/v1/generate
Content-Type: application/json
Authorization: Bearer YOUR_DIAGRAM_API_KEY

{
  "diagram_type": "flowchart",
  "title": "Machine Learning Pipeline",
  "description": "Data collection from 50,000 patient records → Data cleaning and normalisation → Feature engineering → Model training (Random Forest, SVM, Neural Network) → Cross-validation → Performance evaluation → Deployment",
  "style": "modern",
  "output_format": "svg"
}

API Call for Results Comparison Diagram:

Copy
POST https://api.diagram.cloud/v1/generate
Content-Type: application/json
Authorization: Bearer YOUR_DIAGRAM_API_KEY

{
  "diagram_type": "comparison",
  "title": "Our Model vs. Traditional Diagnosis",
  "comparisons": [
    {
      "category": "Accuracy",
      "traditional": "87%",
      "our_model": "94%"
    },
    {
      "category": "Time per Diagnosis",
      "traditional": "2.5 hours",
      "our_model": "1.5 hours"
    },
    {
      "category": "False Positive Rate",
      "traditional": "5%",
      "our_model": "2%"
    }
  ],
  "style": "modern",
  "output_format": "svg"
}

Both responses return URLs to your generated diagrams, which you can embed directly into your presentation slides.

Step 3:

Convert Key Statistics into Infographics

Numbers buried in text don't stick in people's minds. Infographics do. This step takes your key findings and converts them into visual assets.

What happens: You provide statistics and key messages, and text2infographic returns infographic templates you can drop into your slides. Request one infographic per major finding.

API Call:

Copy
POST https://api.text2infographic.io/v1/create
Content-Type: application/json
Authorization: Bearer YOUR_TEXT2INFOGRAPHIC_KEY

{
  "title": "Key Performance Metrics",
  "data_points": [
    {
      "label": "Diagnostic Accuracy",
      "value": "94%",
      "context": "vs 87% traditional methods"
    },
    {
      "label": "Time Saved per Diagnosis",
      "value": "40%",
      "context": "Reduction vs conventional approach"
    },
    {
      "label": "False Positive Rate",
      "value": "2%",
      "context": "Consistently across all demographics"
    }
  ],
  "colour_scheme": "professional_blue",
  "output_format": "png"
}

Response includes a URL to your infographic PNG, ready for slides.

Orchestration:

Tying It All Together with Claude Code

Now we orchestrate these three tools into a single workflow. Claude Code can execute this entire sequence without manual intervention.

The script (pseudocode first, then real implementation):

1. Read your research paper PDF from a URL or local storage.
2. Call chat-with-pdf-by-copilotus to extract structured JSON.
3. Pass the JSON to the diagram tool to generate methodology and results diagrams.
4. Pass key findings and statistics to text2infographic to generate infographics.
5. Compile all outputs (diagrams, infographics, structured text) into a simple JSON manifest that you can import into your presentation software.

Real implementation using Claude Code:

Copyimport requests
import json
import time

COPILOTUS_API_KEY = "your-key-here"
DIAGRAM_API_KEY = "your-key-here"
TEXT2INFOGRAPHIC_KEY = "your-key-here"
PDF_URL = "https://your-storage.com/research-paper.pdf"

# Step 1: Extract insights from PDF
def extract_paper_insights(pdf_url):
    endpoint = "https://api.copilotus.chat/v1/chat"
    payload = {
        "document_url": pdf_url,
        "query": """Extract in JSON format:
        1. title (string)
        2. abstract (string, max 100 words)
        3. key_findings (array of 5 bullet points)
        4. methodology (string, 2-3 sentences)
        5. conclusions (string)
        6. key_statistics (array of objects with 'label' and 'value' fields)
        """,
        "response_format": "json"
    }
    headers = {"Authorization": f"Bearer {COPILOTUS_API_KEY}"}
    response = requests.post(endpoint, json=payload, headers=headers)
    return response.json()

# Step 2: Generate methodology diagram
def generate_methodology_diagram(methodology_text):
    endpoint = "https://api.diagram.cloud/v1/generate"
    payload = {
        "diagram_type": "flowchart",
        "title": "Research Methodology",
        "description": methodology_text,
        "style": "modern",
        "output_format": "svg"
    }
    headers = {"Authorization": f"Bearer {DIAGRAM_API_KEY}"}
    response = requests.post(endpoint, json=payload, headers=headers)
    return response.json().get("diagram_url")

# Step 3: Generate infographics
def generate_infographics(statistics):
    endpoint = "https://api.text2infographic.io/v1/create"
    data_points = [
        {
            "label": stat["label"],
            "value": stat["value"],
            "context": stat.get("context", "")
        }
        for stat in statistics
    ]
    payload = {
        "title": "Key Findings",
        "data_points": data_points,
        "colour_scheme": "professional_blue",
        "output_format": "png"
    }
    headers = {"Authorization": f"Bearer {TEXT2INFOGRAPHIC_KEY}"}
    response = requests.post(endpoint, json=payload, headers=headers)
    return response.json().get("infographic_url")

# Main orchestration
def build_presentation(pdf_url):
    print("Step 1: Extracting insights from PDF...")
    insights = extract_paper_insights(pdf_url)
    
    print("Step 2: Generating methodology diagram...")
    diagram_url = generate_methodology_diagram(insights["methodology"])
    
    print("Step 3: Generating infographics...")
    infographic_url = generate_infographics(insights["key_statistics"])
    
    # Compile manifest
    manifest = {
        "presentation_title": insights["title"],
        "slides": [
            {
                "slide_number": 1,
                "type": "title_slide",
                "title": insights["title"],
                "subtitle": "Research Presentation"
            },
            {
                "slide_number": 2,
                "type": "text",
                "title": "Abstract",
                "content": insights["abstract"]
            },
            {
                "slide_number": 3,
                "type": "diagram",
                "title": "Methodology",
                "diagram_url": diagram_url
            },
            {
                "slide_number": 4,
                "type": "infographic",
                "title": "Key Findings",
                "infographic_url": infographic_url
            },
            {
                "slide_number": 5,
                "type": "bullets",
                "title": "Key Takeaways",
                "bullets": insights["key_findings"]
            },
            {
                "slide_number": 6,
                "type": "text",
                "title": "Conclusions",
                "content": insights["conclusions"]
            }
        ]
    }
    
    return manifest

# Execute
if __name__ == "__main__":
    manifest = build_presentation(PDF_URL)
    with open("presentation_manifest.json", "w") as f:
        json.dump(manifest, f, indent=2)
    print("Presentation manifest saved to presentation_manifest.json")

This script runs in roughly 2-5 minutes, depending on API response times. Your output is a structured JSON file that you can import into PowerPoint, Google Slides, or any presentation tool that accepts JSON imports.

Using Zapier or n8n Instead

If you prefer a visual workflow interface over code, both Zapier and n8n support this workflow:

Zapier approach:

• Trigger: Webhook (you send a POST request with your PDF URL).

• Step 1: Copilotus Chat action (extract insights).

• Step 2: Diagram API action (generate flowchart).

• Step 3: Text2Infographic action (generate infographics).

• Step 4: Send compiled results to your email or cloud storage.

n8n approach:

• Trigger: Manual (run on demand) or Webhook.

• Nodes for each API call (Copilotus, Diagram, Text2Infographic).

• A Function node to compile the manifest JSON.

• A final node to write results to a file or send via email.

Both are point-and-click, requiring no coding knowledge.

The Manual Alternative

Some researchers prefer more control over each step. If you want to review and edit outputs between stages, do this manually:

1. Open your research paper in chat-with-pdf-by-copilotus, read through the insights it extracts, and manually refine the key findings if needed.

2. Copy the refined methodology description into the diagram tool, review the generated flowchart, and request modifications if the layout doesn't match your vision.

3. Take the key statistics and adjust them for clarity before feeding them to text2infographic.

4. Manually arrange the diagrams, infographics, and text into your presentation software.

This approach takes 45-60 minutes instead of 30, but gives you granular control over messaging and visual design. The trade-off is worth it if your conference has strict branding guidelines or if you want to tweak statistics for emphasis.

Pro Tips

Tip 1: Handle API Rate Limits

Copilotus and text2infographic often rate-limit to 10-20 requests per minute. If you're running multiple presentations through this workflow, add delays between orchestration calls:

Copyimport time
time.sleep(2)  # Wait 2 seconds between API calls

Tip 2: Store Diagram and Infographic URLs Permanently

By default, generated diagrams and infographics may be temporary (expiring in 24-48 hours). Download them and store them in your own cloud storage (Google Drive, AWS S3, Azure Blob) immediately after generation:

Copyimport urllib.request

def download_asset(url, filename):
    urllib.request.urlretrieve(url, filename)
    return filename

Tip 3: Customise Colour Schemes for Your Institution

Most tools accept colour scheme parameters. Match your university or company brand:

Copy{
  "colour_scheme": "custom",
  "primary_colour": "#003366",
  "secondary_colour": "#FF6600"
}

Tip 4: Request Alternative Formats

If a diagram doesn't work in your presentation software, request PNG or PDF instead of SVG. SVG is scalable but sometimes has rendering issues in older software:

Copy{
  "output_format": "png",
  "resolution": "300dpi"
}

Tip 5: Monitor Costs on Large Workflows

If you're building presentations from dozens of papers, costs add up. Copilotus charges per PDF upload, text2infographic charges per infographic. Check your API usage dashboard weekly and set spending alerts.

Cost Breakdown

For a single presentation, your cost is roughly £15–£25. For 10 presentations, cost-per-presentation drops to £8–£18. Beyond 20 presentations monthly, consider moving to higher-tier plans or self-hosting n8n to reduce costs.