Convert pitch deck files (.pptx or .pdf) into a beautiful, responsive single-file HTML presentation.
When to Use
Use this skill when:
- The user already has
.pptxor.pdffiles and needs to convert them into a shareable webpage - The user needs to share roadshow materials via email, WeChat, QR code, or browser
- The user needs to view the PPT on a phone
- The user needs an online presentation rather than a file attachment
Do NOT use this skill if:
- The user needs to create a BP from scratch → use
pitch-deck-creatorinstead - The user needs to edit the source PPT content → edit first, then convert
- The input file is missing or unreadable → ask for the correct file path
Typical triggers:
- "Convert PPT to webpage" "BP online presentation" "Generate HTML version of PPT"
- "pitch deck to link" "PPT to view on a phone" "web version roadshow materials"
- "convert pitch to web", "PPT to HTML", "share presentation online"
Workflow
This workflow follows a six-step progression method, with 6 steps in total:
- Probe (Probe): Before starting, fully read all inputs and confirm the goals and constraints.
- Constrain (Constrain): Verify input completeness, set boundaries and non-degradable delivery standards, and switch channels when blocked.
- Evidence (Evidence): Every number must come from the input, a specific source, or reproducible calculation, and supporting data must be collected.
- Execute (Execute): Call scripts/APIs/generate content, giving impact and conclusions first, then actions and necessary evidence.
- Verify (Verify): Verify with actions that "may fail"—read back the output in a way different from the generation path.
- Deliver (Deliver): Return the results and clean up temporary files.
Step 1: Probe (Probe)
Confirm the input file path. Supported formats:
.pptx— PowerPoint file.pdf— PDF file
If the user does not provide a file path, ask proactively.
Step 2: Constrain (Constrain)
Set output boundaries:
- The output must bea single self-contained HTML file, with zero external dependencies
- The output HTML must be saved to the same directory as the input file, using the same base name +
_presentation.html - Retain all textual content from the source file, without summarizing or omitting
- Chinese characters must render correctly
- When blocked, switch channels (e.g., generate a script and guide the user to install it when dependencies are missing), without degrading the deliverable
Step 3: Evidence (Evidence)
Extract all content from the source file as evidence:
- .pptx file: Use
python-pptxto extract all slide content—text, shapes, tables, images (base64-encoded), layout information, and colors - .pdf file: Use
pymupdf(fitz) to extract the text, images (base64), and page structure of each page - The content of each slide comes from source file extraction, with no fabrication
Step 4: Execute (Execute)
Generate and run a Python script to extract content and generate the complete HTML. Give impact and conclusions first, then actions and necessary evidence.
HTML output specifications
Architecture:
- Single
.htmlfile, fully self-contained (CSS + JS inline, images as base64 data URI) - No CDN links, no external fonts, no external JS—100% offline usable
- Use system fonts:
-apple-system, BlinkMacSystemFont, "Segoe UI", "Microsoft YaHei", sans-serif
Presentation mode: The HTML should serve as a slide-based presentation, with:
- Slide navigation: arrow keys (← →), click, or swipe to switch
- Slide indicator: dots at the bottom show the current position
- Progress bar: a thin bar at the top shows presentation progress
- Fullscreen toggle: button to enter/exit fullscreen (F key shortcut)
- Slide count: "3 / 10" indicator
- Smooth transitions: CSS transitions between slides (slide or fade in)
- Responsive: supports desktop, tablet, and mobile
Visual design:
Design tokens:
- Background: linear-gradient(135deg, #0f0f1a, #1a1a2e) (dark mode default)
- Slide background: #ffffff with subtle shadow
- Primary accent: extract from source file, fallback to #1a73e8
- Text: #202124 (dark), #5f6368 (secondary)
- Slide aspect ratio: 16:9
- Max slide width: 1200px, centered
- Slide padding: 60px
- Border radius: 12px on slide container
- Box shadow: 0 20px 60px rgba(0,0,0,0.3)
HTML template structure:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{Project Name} — Business Plan</title>
<style>
/* Reset + Base styles */
/* Slide container styles */
/* Navigation styles */
/* Responsive breakpoints */
/* Print styles */
/* Animation keyframes */
</style>
</head>
<body>
<!-- Progress bar -->
<div class="progress-bar"><div class="progress-fill"></div></div>
<!-- Slides container -->
<div class="slides-container">
<div class="slide active" data-index="0">
<!-- Slide content reconstructed from source -->
</div>
<!-- ... more slides ... -->
</div>
<!-- Navigation -->
<div class="nav-dots">
<span class="dot active"></span>
<!-- ... -->
</div>
<div class="slide-counter">1 / 10</div>
<button class="fullscreen-btn" title="Fullscreen (F)">⛶</button>
<button class="nav-arrow prev" title="Previous (←)">‹</button>
<button class="nav-arrow next" title="Next (→)">›</button>
<script>
// Slide navigation logic
// Keyboard shortcuts (←, →, F, Escape)
// Touch/swipe support
// Fullscreen API
// Progress bar update
</script>
</body>
</html>
Content mapping rules:
| Source Element | HTML Rendering |
|---|---|
| Slide title | <h1> or <h2> with accent underline |
| Subtitle | <p class="subtitle"> |
| Body text | <p> with proper spacing |
| Bullet points | <ul> with styled list items |
| Tables | <table> with striped rows and hover effects |
| Images | <img> with base64 src, responsive sizing |
| Charts/shapes | Describe as styled <div> blocks or reconstruct with CSS |
| Stat numbers | Large <span class="stat"> with label below |
| Cards | <div class="card"> with shadow and border |
| Timeline | Horizontal flex layout with dots and lines |
| Comparison table | Feature matrix with ✓/✗ icons |
Slide type-specific styles:
- Cover: full-bleed dark background, large title, gradient overlay
- Pain points: colorful cards in a grid
- Solution: feature cards with icons
- Business model: revenue breakdown with visual bars
- Product demo: centered image/model diagram + annotations
- Competitive analysis: styled comparison table
- Traction: metrics row + timeline visualization
- Roadmap: phase cards connected by arrows
- Team: a row of avatar cards
- Financing: key statistics + use of funds bar chart
Python script requirements
The script must:
- Accept the input file path as a variable or argument
- Detect the file type (.pptx or .pdf) and use the appropriate extraction method
- Extract all text content and preserve hierarchy (title vs body)
- Extract images and convert them to base64 data URIs
- For .pptx: extract shape positions, colors, and font sizes to guide layout
- For .pdf: extract text blocks with position data and embedded images
- Generate complete HTML with inline CSS and JS
- Correctly handle Chinese and English text
- Save the output file and print the path
- Dependencies:
python-pptx、pymupdf(fitz)、base64、os
Script template
#!/usr/bin/env python3
"""Deck to HTML Converter by Unique Club"""
import os
import sys
import base64
def extract_from_pptx(filepath):
"""Extract slide content from a .pptx file."""
from pptx import Presentation
from pptx.util import Inches, Pt, Emu
# ... extract text, images, layout from each slide
# Return list of slide dicts with content
pass
def extract_from_pdf(filepath):
"""Extract page content from a .pdf file."""
import fitz # pymupdf
# ... extract text blocks, images from each page
# Return list of slide dicts with content
pass
def detect_slide_type(slide_data, index, total):
"""Heuristically detect slide type for enhanced styling."""
# Cover (first slide), Fundraising (last slide), etc.
pass
def generate_html(slides, title, accent_color="#1a73e8"):
"""Generate complete self-contained HTML presentation."""
# Build CSS, HTML slides, JS navigation
pass
def main():
input_file = INPUT_FILE # Set by the skill
ext = os.path.splitext(input_file)[1].lower()
if ext == ".pptx":
slides = extract_from_pptx(input_file)
elif ext == ".pdf":
slides = extract_from_pdf(input_file)
else:
print(f"Unsupported format: {ext}")
sys.exit(1)
title = os.path.splitext(os.path.basename(input_file))[0]
html = generate_html(slides, title)
output_file = os.path.splitext(input_file)[0] + "_presentation.html"
with open(output_file, "w", encoding="utf-8") as f:
f.write(html)
print(f"HTML presentation generated: {output_file}")
if __name__ == "__main__":
main()
Step 5: Verify
Read back the output in a different way from the generation path:
- Open the HTML in a browser and confirm all slides render correctly
- Test keyboard navigation (← →), fullscreen (F), and swipe operations
- Confirm that all text content matches the source file with no omissions
- Verify that Chinese characters render correctly
- Check that the responsive layout works properly on mobile
- Confirm the file size is reasonable (<10MB, unless the source file has many large images)
- Test print functionality (including @media print styles)
Step 6: Deliver
Return results, clean up temporary files:
- Inform the user of the output file path
- Explain that it can be opened directly in the browser
- Mention keyboard shortcuts: ← → to navigate, F for fullscreen
- Provide the file path for easy copying and sharing
- If the user requests, a QR code can be generated for mobile access
Output
Output constraints
- Single HTML file, fully self-contained, zero external dependencies
- File size should be reasonable (<10MB, unless the source file has many large images)
- Must work properly in Chrome, Safari, Firefox, Edge
- Must be printable (including @media print styles)
- Retain all text content from the source file — do not summarize or omit
- Chinese characters must render correctly
Output file naming
Save the output HTML to the same directory as the input file, using the same base name + _presentation.html。
Guardrails
Anti-patterns
- NEVER output non-self-contained HTML — external CDN links are prohibited
- Do NOT omit slides or summary content — retain all text from the source file
- Do NOT fail to warn the user that the HTML may be very large when the source file contains large images (>2MB each)
- NEVER save the HTML to a directory different from the input file or use a different base name
- Do NOT give up when dependencies are missing — generate a script and guide the user to install the required dependencies
Constraints
- The output must be a single
.htmlfile - Supports
.pptxand.pdftwo input formats - Depends on
python-pptxandpymupdf, guide installation if missing - Images are inlined as base64 data URIs
- Use system fonts, do not rely on external fonts
- 16:9 slide aspect ratio, max width 1200px centered
Related Skills
- pitch-deck-creator — Create a professional pitch deck from scratch, then convert it to HTML to complete the full workflow from creation to sharing
- business-plan-ppt — Create an 18-page Chinese-style business plan PPT, then use this skill to convert it into a webpage for sharing
- fundraising-bp-planner — First outline the fundraising BP before creating and converting the deck
About UniqueClub
This skill is part of the UniqueClub founder toolkit. 🌐 https://uniqueclub.ai 📂 https://github.com/wulaosiji/founder-skills