Academic Conference Presentation Deck from Research Paper

Converting a research paper into a conference presentation deck is tedious work that falls between skill sets. Academics write papers; designers make presentations. The person stuck doing both ends up spending days extracting key points, reformatting text, creating visuals, and wrestling with PowerPoint templates. This is exactly the type of work that wastes human time on tasks machines should handle............. For more on this, see Academic conference presentation deck from research paper.... For more on this, see Academic research paper summarisation and citation extrac....

The good news: modern AI tools can handle this entire pipeline. You can feed a research paper into an extraction tool, have it summarised by another service, then auto-generate slides with proper visualisations. The catch is that these tools don't talk to each other by default. You need an orchestration layer to make them work together without manual copy-pasting between windows.

This workflow uses four specialist tools plus an orchestration platform to turn a PDF research paper into a polished presentation deck in minutes. You'll connect them so that each tool's output becomes the next tool's input, with zero human intervention after you hit "start."

The Automated Workflow

We'll use n8n as the orchestration platform because it has excellent native support for all four tools and runs on your own infrastructure or a hosted version. If you prefer Zapier, the logic is identical but you'll need to use Zapier's built-in HTTP modules. Make (Integromat) works similarly but with slightly different syntax.

Step 1:

Extract and Structure the Paper (bhava-ai)

Bhava-ai specialises in extracting structured data from documents. It understands academic papers and can pull out abstract, methodology, results, and conclusions in JSON format.

First, upload your paper to bhava-ai via their API or use their document upload endpoint. The service will parse it and return a structured JSON object.

Copy
POST https://api.bhava-ai.com/v1/documents/parse
Content-Type: application/json
Authorization: Bearer YOUR_BHAVA_API_KEY

{
  "document_type": "research_paper",
  "extract_sections": [
    "abstract",
    "introduction",
    "methodology",
    "results",
    "conclusions",
    "key_findings"
  ],
  "output_format": "json"
}

The response looks like this:

Copy{
  "document_id": "paper_12345",
  "abstract": "This study investigates...",
  "introduction": "Background and context...",
  "methodology": "We conducted experiments...",
  "results": "Our findings show...",
  "conclusions": "In summary...",
  "key_findings": [
    "Finding 1 with quantified impact",
    "Finding 2 with quantified impact"
  ],
  "metadata": {
    "title": "Novel Approach to X",
    "authors": ["Smith, J.", "Jones, K."],
    "year": 2024
  }
}

In n8n, add an HTTP Request node and map this endpoint. Configure it to use your API key from a credential stored securely in n8n's vault.

Step 2:

Simplify the Content (ExplainPaper)

Your extracted paper is still dense. ExplainPaper breaks down complex text into accessible summaries. This is crucial for a presentation audience who won't read a ten-page paper in a conference room.

Pass the key sections from step 1 into ExplainPaper's summarisation API:

Copy
POST https://api.explainpaper.com/v1/summarise
Content-Type: application/json
Authorization: Bearer YOUR_EXPLAINPAPER_API_KEY

{
  "text": "Our findings show that the proposed algorithm achieves 94% accuracy on the benchmark dataset, outperforming existing methods by 8 percentage points. The computational overhead is reduced by 35% due to optimised feature extraction.",
  "summary_length": "short",
  "target_audience": "conference_attendee",
  "preserve_metrics": true
}

The response is a simplified version suitable for a slide:

Copy{
  "original_length": 287,
  "summary_length": 67,
  "summary": "Our method achieves 94% accuracy, beating existing approaches by 8 points, while using 35% less computational power.",
  "key_metrics": [
    {"metric": "accuracy", "value": "94%"},
    {"metric": "improvement", "value": "8 percentage points"},
    {"metric": "efficiency_gain", "value": "35% reduction"}
  ]
}

In n8n, add another HTTP Request node and feed it the structured data from bhava-ai. Use the n8n expression language to extract sections dynamically:

Copy
{{ $json.methodology }}

Process each major section (methodology, results, conclusions) through ExplainPaper in separate API calls, or batch them if the API supports it.

Step 3:

Generate Visual Assets (Text2Infographic)

Text2Infographic converts data and descriptions into visual diagrams, charts, and infographic layouts. This is where your raw numbers become audience-ready graphics.

Send your simplified results and key metrics:

Copy
POST https://api.text2infographic.com/v1/generate
Content-Type: application/json
Authorization: Bearer YOUR_TEXT2INFOGRAPHIC_API_KEY

{
  "input_type": "metrics_and_description",
  "data": {
    "title": "Performance Comparison",
    "metrics": [
      {"label": "Our Method", "value": 94},
      {"label": "Baseline A", "value": 86},
      {"label": "Baseline B", "value": 87}
    ],
    "description": "Our novel approach outperforms existing methods on the benchmark dataset."
  },
  "visual_style": "modern_minimal",
  "output_format": "png",
  "dimensions": {
    "width": 1920,
    "height": 1080
  }
}

The service returns a URL to a high-resolution PNG:

Copy{
  "infographic_id": "inf_98765",
  "image_url": "https://cdn.text2infographic.com/inf_98765_final.png",
  "size_bytes": 245000,
  "generation_time_ms": 3200,
  "dimensions": [1920, 1080]
}

Store these image URLs because you'll need them in the next step.

Step 4:

Build the Presentation Deck (Preswald-ai)

Preswald-ai is the final piece. It generates presentation decks from structured content and image assets. Feed it the simplified text from ExplainPaper plus the visual assets from Text2Infographic.

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

{
  "title": "Novel Approach to X",
  "author": "Smith, J. & Jones, K.",
  "slides": [
    {
      "slide_number": 1,
      "type": "title_slide",
      "content": {
        "title": "Novel Approach to X",
        "subtitle": "Research Findings and Implications",
        "authors": ["Smith, J.", "Jones, K."],
        "date": "2024"
      }
    },
    {
      "slide_number": 2,
      "type": "text_slide",
      "content": {
        "title": "Problem Statement",
        "body": "Existing algorithms struggle with scalability and accuracy on large datasets."
      }
    },
    {
      "slide_number": 3,
      "type": "image_slide",
      "content": {
        "title": "Our Results",
        "image_url": "https://cdn.text2infographic.com/inf_98765_final.png",
        "caption": "Performance comparison across three benchmark datasets."
      }
    },
    {
      "slide_number": 4,
      "type": "text_slide",
      "content": {
        "title": "Conclusions",
        "body": "Our method achieves 94% accuracy with 35% less computational overhead."
      }
    }
  ],
  "template": "academic_professional",
  "output_format": "pptx"
}

Preswald returns a download URL:

Copy{
  "presentation_id": "pres_56789",
  "download_url": "https://cdn.preswald-ai.com/pres_56789_final.pptx",
  "slide_count": 8,
  "file_size_bytes": 1850000,
  "ready": true
}

Putting It Together in n8n

Here's the complete workflow structure in n8n:

Copy
[Trigger: Manual or Schedule] 
    ↓
[HTTP Request: Upload to bhava-ai]
    ↓
[HTTP Request: Extract paper structure]
    ↓
[For Each: Process sections through ExplainPaper]
    ↓
[HTTP Request: Generate infographics from results]
    ↓
[Function Node: Build Preswald payload from all prior outputs]
    ↓
[HTTP Request: Create presentation]
    ↓
[Send Email: Deliver download link]

Create a Function node to assemble the final Preswald payload. This node takes outputs from all previous steps and structures them correctly:

Copyconst bhavaOutput = $json.bhava_extraction;
const explainpaperSummaries = $json.simplified_sections;
const infographicUrls = $json.visual_assets;

const slides = [
  {
    slide_number: 1,
    type: "title_slide",
    content: {
      title: bhavaOutput.metadata.title,
      subtitle: "Research Findings",
      authors: bhavaOutput.metadata.authors,
      date: new Date().getFullYear().toString()
    }
  },
  {
    slide_number: 2,
    type: "text_slide",
    content: {
      title: "Introduction",
      body: explainpaperSummaries.introduction
    }
  },
  {
    slide_number: 3,
    type: "image_slide",
    content: {
      title: "Key Results",
      image_url: infographicUrls[0],
      caption: "Performance metrics"
    }
  },
  {
    slide_number: 4,
    type: "text_slide",
    content: {
      title: "Conclusions",
      body: explainpaperSummaries.conclusions
    }
  }
];

return {
  slides: slides,
  template: "academic_professional"
};

After the Function node, add the final HTTP Request to Preswald using the structured output. Once Preswald returns the presentation URL, add an Email node to send it to yourself or your colleagues with a download link.

The Manual Alternative

If you prefer direct control over which points appear on each slide, or if your paper has unconventional structure that automated extraction might miss, you can use these tools semi-manually. Export the JSON from bhava-ai, copy key sections into ExplainPaper one at a time, hand-select which metrics to visualise, and then build your Preswald presentation with custom narrative flow. This takes longer but gives you final approval on every slide. For a high-stakes conference talk, this trade-off might be worthwhile.

Alternatively, do the extraction and simplification automatically but download the visual assets and manually insert them into an existing PowerPoint template using Preswald only for formatting and styling.

Pro Tips

Error Handling and Retries. API calls fail. Network timeouts happen. In n8n, add a Retry node after each HTTP Request. Set it to retry up to 3 times with exponential backoff (1 second, then 2 seconds, then 4 seconds). This prevents the entire workflow from failing because ExplainPaper briefly went offline.

Copy{
  "retry": true,
  "maxRetries": 3,
  "backoff": "exponential",
  "initialDelay": 1000
}

Rate Limits. All four tools have rate limits, usually measured in requests per minute. If you process a paper with 20 major sections, you might hit ExplainPaper's limit. Add a Wait node between batch calls to space them out by 5 seconds. This costs time upfront but prevents 429 errors that will break your workflow.

Cost Optimisation. Preswald charges per slide generated. Don't create 50 slides; create 10 good ones. Keep presentations between 8 and 12 slides, which is standard anyway. Text2Infographic charges per image. Reuse the same metric visualisation across slides where appropriate rather than generating new graphics each time.

Webhook Triggers. Instead of manual triggers, use n8n's Webhook node to trigger the entire workflow when a paper is uploaded to Google Drive or Dropbox. This turns it into a proper service: drop a PDF into a folder, and a presentation appears in another folder 2 minutes later.

Testing. Before running the full workflow on your important conference paper, test it on a short, simple paper first. This lets you catch configuration errors without wasting API quota on a critical document.

Cost Breakdown

If you run this workflow once per week on 4 papers, you'll use roughly 200 bhava-ai documents, 800 ExplainPaper requests, 4 Preswald presentations, and 4 Text2Infographic graphics monthly. You'll stay well within all tier limits. For a single conference paper, you could run it on free tier trials from most vendors if you're willing to set it up multiple times.

The entire system takes 90 seconds to 3 minutes per paper once configured, depending on API response times. Manual conversion takes 2 to 4 hours. The return on setup time is high if you process more than one paper per month.