Academic conference presentation deck from research paper in 30 minutes

You've just finished a research paper. It's solid work, backed by months of investigation. Now you need to present it at a conference in four weeks. The problem is obvious: converting that PDF into a compelling presentation deck typically requires hours of manual work. You'd need to read through the paper, extract key findings, design slides, create visualisations, and manually build everything in PowerPoint or Google Slides. Most researchers end up spending 8 to 12 hours on this task alone.......

What if you could automate 90 per cent of that work and have a draft presentation ready in 30 minutes?

This is precisely where combining multiple AI tools into an automated workflow becomes genuinely useful. Rather than switching between different applications and copying text back and forth, you can wire together a chain of AI services that extracts content from your paper, generates structured presentation outlines, creates visual diagrams, and produces infographics. The data flows automatically from one tool to the next with zero manual intervention. You upload your research paper once, and a complete presentation deck emerges on the other end.

The Automated Workflow

For this workflow, we'll use n8n as our orchestration platform. n8n is self-hosted or cloud-based, offers generous free tiers, and handles complex multi-step automation without requiring code expertise. Zapier and Make are solid alternatives if you prefer managed solutions, but n8n gives you the most flexibility for this particular task.

Here's the overall flow:

1. Upload your research PDF to cloud storage (Google Drive or similar).
2. Chat-with-PDF-by-Copilotus extracts key sections: abstract, methodology, results, conclusions.
3. The extracted text is structured into presentation sections.
4. Diagram AI generates visual representations of your research methodology and findings.
5. Text2Infographic converts statistical results and data points into visual infographics.
6. All outputs are compiled and formatted into a presentation deck (JSON or markdown that can be imported into slide software).

Setting up n8n

Start by creating an n8n account at app.n8n.cloud or self-hosting an instance. Once you're logged in, create a new workflow.

The first node should be a trigger. For simplicity, we'll use a "Manual Trigger" to test, but in production you'd use a "Webhook" that fires when a file is uploaded, or a "Google Drive" node that monitors a specific folder.

Step 1: Extract Content from PDF

Add a new node and search for "HTTP Request." This is how we'll call the Chat-with-PDF-by-Copilotus API.

Copy
{
  "method": "POST",
  "url": "https://api.copilotus.io/v1/documents/upload",
  "headers": {
    "Authorization": "Bearer YOUR_COPILOTUS_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "file_url": "{{ $json.pdf_url }}",
    "document_type": "research_paper"
  }
}

The $json.pdf_url placeholder assumes your manual trigger (or webhook) passes the URL of your uploaded PDF. Copilotus will return a document ID.

Once you have the document ID, create a second HTTP Request node to query specific sections:

Copy
{
  "method": "POST",
  "url": "https://api.copilotus.io/v1/documents/{{ $json.document_id }}/query",
  "headers": {
    "Authorization": "Bearer YOUR_COPILOTUS_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "questions": [
      "What is the research question or hypothesis?",
      "What methodology was used?",
      "What were the main findings?",
      "What are the conclusions and future work?"
    ]
  }
}

Store the responses in a variable. The node output will contain structured answers to each question, which become the skeleton of your presentation.

Step 2: Generate Diagrams

Add a node for the Diagram API (such as Excalidraw's API or a custom diagram service). We'll create a workflow diagram based on the methodology.

Copy
{
  "method": "POST",
  "url": "https://api.excalidraw.com/v1/diagrams",
  "headers": {
    "Authorization": "Bearer YOUR_DIAGRAM_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "title": "Research Methodology",
    "description": "{{ $json.methodology_text }}",
    "diagram_type": "flowchart",
    "style": "minimalist"
  }
}

This returns a URL to an embedded diagram. Store this URL for later inclusion in your presentation.

Alternatively, if you're using Claude Code (available through Anthropic's API), you could generate diagram definitions in a format like Mermaid:

Copy
{
  "method": "POST",
  "url": "https://api.anthropic.com/v1/messages",
  "headers": {
    "Authorization": "Bearer YOUR_ANTHROPIC_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Create a Mermaid flowchart diagram for this research methodology: {{ $json.methodology_text }}. Return only the Mermaid syntax."
      }
    ]
  }
}

Claude will return Mermaid syntax, which you can then render using a Mermaid viewer or include directly in markdown-based presentations.

Step 3: Generate Infographics

Add another HTTP Request node for Text2Infographic. This tool converts data and statistics into visual representations.

Copy
{
  "method": "POST",
  "url": "https://api.text2infographic.com/v1/generate",
  "headers": {
    "Authorization": "Bearer YOUR_TEXT2INFOGRAPHIC_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "content": "{{ $json.findings_text }}",
    "infographic_type": "statistics",
    "format": "svg",
    "colour_scheme": "professional"
  }
}

The service returns an SVG or PNG file that visualises your key results. This becomes a slide on its own.

Step 4: Compile Outputs

Now add a "Function" node (or "Code" node in n8n) to structure everything into a presentation object:

Copy// n8n Function Node
return [{
  "presentation": {
    "title": $json.paper_title,
    "author": $json.author,
    "slides": [
      {
        "slide_number": 1,
        "type": "title",
        "title": $json.paper_title,
        "subtitle": "Conference Presentation"
      },
      {
        "slide_number": 2,
        "type": "text",
        "title": "Research Question",
        "content": $json.research_question
      },
      {
        "slide_number": 3,
        "type": "diagram",
        "title": "Methodology",
        "image_url": $json.methodology_diagram_url
      },
      {
        "slide_number": 4,
        "type": "text_with_image",
        "title": "Key Findings",
        "content": $json.findings_text,
        "image_url": $json.infographic_url
      },
      {
        "slide_number": 5,
        "type": "text",
        "title": "Conclusions",
        "content": $json.conclusions
      }
    ]
  }
}];

Step 5: Export to Presentation Format

Finally, add a node that exports this JSON structure to an actual presentation format. You have a few options:

1. Google Slides API: Send the JSON directly to create slides in Google Slides.
2. PowerPoint via Python: Use a node that calls a Python script (via HTTP) to generate a .pptx file.
3. RevealJS: Generate HTML/markdown that renders as an interactive web presentation.

For Google Slides, here's the final node:

Copy
{
  "method": "POST",
  "url": "https://www.googleapis.com/slides/v1/presentations",
  "headers": {
    "Authorization": "Bearer YOUR_GOOGLE_OAUTH_TOKEN",
    "Content-Type": "application/json"
  },
  "body": {
    "title": "{{ $json.paper_title }} - Conference Presentation"
  }
}

This creates a blank presentation. Then, iterate through each slide in your JSON and use the "batchUpdate" endpoint to add content:

Copy
{
  "method": "POST",
  "url": "https://www.googleapis.com/slides/v1/presentations/{{ $json.presentation_id }}/batchUpdate",
  "headers": {
    "Authorization": "Bearer YOUR_GOOGLE_OAUTH_TOKEN",
    "Content-Type": "application/json"
  },
  "body": {
    "requests": [
      {
        "addSlide": {
          "slideLayout": "layouts/TITLE"
        }
      }
    ]
  }
}

You'd execute one batchUpdate call per slide, adding text and images as defined in your JSON structure.

Connecting the Workflow

In n8n, connect the nodes in this sequence:

Manual Trigger → PDF Upload/Query → Diagram Generation → Infographic Generation → Compilation Function → Google Slides Export For more on this, see Dora AI vs v0 vs Diagram: AI Web Design and UI Generation....

Each node's output becomes available as input to the next node. Use n8n's expression syntax {{ $json.field_name }} to reference data from previous nodes.

Save the workflow and run a test with a sample PDF. Watch as each step executes and your presentation takes shape.

The Manual Alternative

If you prefer direct control over each stage, here's what that looks like:

1. Open Chat-with-PDF-by-Copilotus in your browser, upload your PDF, and manually extract key sections by asking specific questions. Copy the results to a text editor.

2. Use Diagram (Excalidraw, Lucidchart, or similar) to create your methodology flowchart by hand, based on the extracted methodology text.

3. Open Text2Infographic, paste your statistical results, and generate infographics one at a time. Download each image.

4. Create your presentation deck in Google Slides or PowerPoint, manually inserting each piece of content: text blocks, diagrams, and infographics.

5. Review and polish: adjust colours, fonts, and layouts to match your preferences.

This approach takes 8 to 12 hours but gives you complete control over presentation aesthetics and messaging. The automated workflow trades some customisation for speed; you get a rough draft in 30 minutes that you then refine for another 30 minutes if needed.

Pro Tips

Rate Limiting and Throttling

Each API has rate limits. Copilotus typically allows 100 requests per minute on free plans; Text2Infographic and diagram services vary. In n8n, add "Wait" nodes between API calls to space them out and avoid hitting limits:

Copy
{
  "type": "wait",
  "duration": 1,
  "unit": "seconds"
}

If you're processing multiple papers, use n8n's built-in rate limiting by setting a "max concurrent executions" value on each HTTP Request node.

Error Handling

Add a "Catch" node after each API call to handle failures gracefully:

Copy// If Copilotus fails to extract text, fall back to a default response
if (error) {
  return [{
    "fallback_content": "Unable to extract from PDF. Please review manually."
  }];
}

This prevents the entire workflow from breaking if one tool is temporarily unavailable.

Cost Optimisation

Run the workflow during off-peak hours if your orchestration tool offers cheaper rates. n8n cloud charges per execution; running batches of presentations overnight costs less than running them during business hours. Use Google Drive's free tier for file storage rather than paid alternatives.

Cache diagram and infographic outputs. If you run this workflow regularly with similar types of papers, store generated diagrams and reuse them rather than regenerating the same visualisations.

Customising the Output

Pass a "style_preferences" parameter through the workflow to customise colours and fonts:

Copy
{
  "style_preferences": {
    "colour_scheme": "dark",
    "font_family": "Roboto",
    "logo_url": "https://your-university.edu/logo.png"
  }
}

This ensures every presentation matches your branding without additional manual work.

Testing and Iteration

Before running on a real paper, test the workflow with a short, simple PDF. Run each node individually to verify API keys are correct and responses are as expected. n8n lets you preview the output of each node in the editor, making debugging straightforward.

Cost Breakdown

If you're an academic institution, both Google Workspace and n8n offer educational discounts. Contact sales teams directly for pricing.

Running this workflow for a single 30-minute presentation costs approximately £0 to £5 depending on which paid tiers you choose. Running it for 10 presentations costs roughly the same amount, since most tools charge monthly rather than per-execution (except n8n, which does charge per execution but includes a generous free tier).