Meta Description

A complete tutorial comparing Quarto and Marp for educators, trainers, DevOps instructors, and course creators. Learn which tool to use for automated slides, PPTX, PDF, reveal.js, HTML, images, speaker notes, templates, and CI/CD-based slide generation.

Target Keywords

• Quarto vs Marp
• Markdown slides
• automated slide creation
• Quarto reveal.js tutorial
• Marp CLI tutorial
• create slides from Markdown
• best slide tool for educators
• generate PPTX from Markdown
• generate PDF slides from Markdown
• DevOps course slide automation
• reveal.js slides using Quarto
• Marp PowerPoint export
• Markdown presentation tools

Quarto vs Marp: Which One Should Educators Use for Automated Slide Creation?

Creating slides manually in PowerPoint works when you are making one presentation. But when you are an educator, trainer, coach, technical instructor, or course creator, PowerPoint quickly becomes painful.

You do not create one slide deck.

You create:

• multiple courses
• multiple modules
• many versions of the same course
• PPTX files for clients
• PDF handouts for students
• HTML slides for online training
• code examples
• diagrams
• labs
• speaker notes
• reusable templates
• branded slides
• updates every few months

At that point, the real question is not:

Which software can create good-looking slides?

The better question is:

Which slide system can help me automate, reuse, publish, version-control, and scale my course content?

That is where tools like Quarto, Marp, and reveal.js become powerful.

In this guide, we will deeply compare Quarto vs Marp and decide which one is best for educators who want to automate slide generation.

1. The Problem with Traditional PowerPoint-Based Slide Creation

PowerPoint is excellent for manual design. But it is not ideal as the main source of truth for a large training business.

PowerPoint becomes difficult when you need to:

• manage hundreds of slides
• reuse content across courses
• update old courses quickly
• maintain consistent branding
• track changes in Git
• generate PDF and HTML automatically
• convert the same content into slides, notes, docs, and website pages
• automate slide generation using scripts or CI/CD

PowerPoint is a good final editing tool, but it is not the best master source for automated education content.

For educators, the better strategy is:

Write course content in Markdown
Generate slides automatically
Export to HTML, PDF, and PPTX
Keep everything in Git
Reuse templates and images
Automate builds

This is the modern slide creation workflow.

2. Best Modern Approach for Educators

The best approach is:

Markdown / Quarto source file
        ↓
Automated build tool
        ↓
HTML slides
PDF handout
PowerPoint file
Website pages

Instead of manually designing every slide, you write content in a clean text format and generate outputs.

Example:

course-topic.qmd
        ↓
Quarto
        ↓
reveal.js HTML slides
PDF
PPTX
Code language: CSS (css)

Or:

course-topic.marp.md
        ↓
Marp CLI
        ↓
HTML
PDF
PPTX
Images
Code language: CSS (css)

This is much better for automation.

3. What Is Quarto?

Quarto is a complete technical publishing system.

It is not only a slide tool.

Quarto can create:

• slides
• HTML pages
• PDFs
• Word documents
• PowerPoint files
• books
• blogs
• websites
• technical tutorials
• data reports
• documentation
• course notes

Quarto files usually use the extension:

.qmd
Code language: CSS (css)

A Quarto slide file may look like this:

---
title: "Introduction to Red Hat OpenShift"
subtitle: "DevOpsSchool Training"
author: "Rajesh Kumar"
format:
  revealjs:
    theme: simple
    slide-number: true
---

# Introduction to Red Hat OpenShift

---

## What is OpenShift?

Red Hat OpenShift is an enterprise Kubernetes platform.

---

## Why OpenShift?

- Enterprise Kubernetes
- Built-in security
- Developer-friendly experience
- CI/CD support
- Integrated registry
- Operators
- Monitoring
Code language: PHP (php)

Quarto is very powerful for educators because the same source file can become:

HTML slides
PDF handout
PowerPoint deck
Course documentation
Website page

4. What Is Marp?

Marp is a Markdown-based slide creation ecosystem.

It is focused mainly on this:

Markdown → Slides

A Marp file usually uses:

.marp.md
Code language: CSS (css)

Example:

---
marp: true
theme: default
paginate: true
footer: "DevOpsSchool"
---

# Introduction to Red Hat OpenShift

---

## What is OpenShift?

Red Hat OpenShift is an enterprise Kubernetes platform.

---

## Why OpenShift?

- Enterprise Kubernetes
- Security
- CI/CD
- Operators
- Monitoring
Code language: PHP (php)

Marp is simple, fast, and very good for creating clean slide decks from Markdown.

Its major strength is simplicity.

You can quickly generate:

HTML
PDF
PPTX
Images

5. What Is reveal.js?

reveal.js is a browser-based HTML presentation framework.

It gives you web-style slides with:

• browser presentation mode
• keyboard navigation
• speaker notes
• fragments
• transitions
• animations
• nested slides
• code highlighting
• PDF export
• web hosting support

You can use reveal.js directly, but for educators, the better way is usually:

Quarto + reveal.js
Code language: CSS (css)

Quarto handles the authoring and automation. reveal.js handles the browser-based slide engine.

So the recommended stack is:

Quarto source file → reveal.js HTML presentation
Code language: CSS (css)

6. Quarto vs Marp in One Sentence

Quarto = full course publishing platform
Marp   = simple Markdown slide generator

That is the most important difference.

If you only want quick slides, Marp is excellent.

If you want a long-term automated course system, Quarto is stronger.

7. Final Recommendation for Educators

For educators, trainers, and course creators:

Use Quarto as your main system.
Use Marp for quick PPTX/PDF slide decks.
Do not use PowerPoint as the master source.
Code language: JavaScript (javascript)

Recommended setup:

Primary authoring format: .qmd
Primary slide engine: reveal.js through Quarto
Secondary export: PPTX
Student handout: PDF
Quick slide tool: Marp
Final manual polish: PowerPoint only if required
Code language: CSS (css)

8. Quarto vs Marp: Full Comparison Table

9. Decision Table

10. Recommended Architecture for Course Automation

The best long-term structure is:

course-name/
├── _quarto.yml
├── slides/
│   ├── 01-introduction.qmd
│   ├── 02-architecture.qmd
│   ├── 03-installation.qmd
│   ├── 04-lifecycle.qmd
│   └── 05-best-practices.qmd
├── marp/
│   └── 01-introduction.marp.md
├── images/
│   ├── architecture.png
│   ├── workflow.png
│   └── lifecycle.png
├── css/
│   ├── reveal.scss
│   └── marp-theme.css
├── templates/
│   └── devopsschool-reference.pptx
├── output/
│   ├── html/
│   ├── pdf/
│   └── pptx/
└── build.sh

This structure keeps everything clean:

source files separate
images separate
themes separate
outputs separate
automation script separate

This is important when you create many courses.

11. Best Folder Structure for One Simple Test

If you are just testing Quarto and Marp with two files, use:

slides/
├── Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
├── Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
├── images/
└── output/

Your current folder:

slides/
├── Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
└── Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd

This is perfect for testing.

12. How to Install Quarto on macOS

Using Homebrew:

brew install --cask quarto

Check installation:

quarto --version

Preview a Quarto slide:

quarto preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
Code language: CSS (css)

Generate reveal.js HTML slides:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to revealjs
Code language: CSS (css)

Generate PowerPoint:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to pptx
Code language: CSS (css)

Generate PDF:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to pdf
Code language: CSS (css)

13. How to Install Marp CLI on macOS

First install Node.js:

brew install node

Check Node:

node --version
npm --version

Install Marp CLI globally:

npm install -g @marp-team/marp-cli
Code language: CSS (css)

Check Marp:

marp --version

If marp command is not found, use npx:

npx @marp-team/marp-cli --version
Code language: CSS (css)

Preview Marp slides:

npx @marp-team/marp-cli --preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Code language: CSS (css)

Generate HTML:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --html --allow-local-files
Code language: CSS (css)

Generate PDF:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pdf --allow-local-files
Code language: CSS (css)

Generate PPTX:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pptx --allow-local-files
Code language: CSS (css)

14. Fix: zsh: command not found: marp

Sometimes Marp installs correctly, but the global npm binary path is not added to your shell PATH.

You may see:

marp --version
zsh: command not found: marp

But this works:

npx @marp-team/marp-cli --version
Code language: CSS (css)

That means Marp is installed, but your shell cannot find the global command.

Check npm global prefix:

npm config get prefix
Code language: JavaScript (javascript)

Example output:

/opt/homebrew/Cellar/node/26.3.1

Check Marp binary:

ls -l "$(npm config get prefix)/bin/marp"
Code language: JavaScript (javascript)

If it exists, add it to PATH:

echo 'export PATH="$(npm config get prefix)/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
rehash
marp --version
Code language: PHP (php)

If that still does not work, add the exact path:

echo 'export PATH="/opt/homebrew/Cellar/node/26.3.1/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
rehash
marp --version
Code language: PHP (php)

If needed, create a stable symlink:

ln -sf /opt/homebrew/Cellar/node/26.3.1/bin/marp /opt/homebrew/bin/marp
rehash
which marp
marp --version

But practically, you are not blocked. You can always run:

npx @marp-team/marp-cli --preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Code language: CSS (css)

15. Sample Quarto Slide File

Create:

Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
Code language: CSS (css)

Content:

---
title: "Introduction to Red Hat OpenShift"
subtitle: "DevOpsSchool Training"
author: "Rajesh Kumar"
format:
  revealjs:
    theme: simple
    slide-number: true
    transition: slide
    logo: images/devopsschool-logo.png
---

# Introduction to Red Hat OpenShift

---

## What is OpenShift?

Red Hat OpenShift is an enterprise Kubernetes platform.

It helps teams build, deploy, run, and manage containerized applications.

---

## Why OpenShift?

- Enterprise Kubernetes platform
- Built-in developer experience
- Integrated CI/CD support
- Strong security model
- Operator-based automation
- Hybrid cloud support

---

## Kubernetes vs OpenShift

| Area | Kubernetes | OpenShift |
|---|---|---|
| Type | Container orchestration | Enterprise Kubernetes platform |
| Security | Configurable | Strong defaults |
| Developer tools | External | Built-in |
| Registry | External | Integrated |
| Routes | Not native | Built-in |

---

## OpenShift Architecture

![](images/openshift-architecture.png)

---

## Example Command

```bash
oc get pods -A
oc get projects
oc get routes -A
Code language: PHP (php)

Speaker Notes Example

OpenShift is not a replacement for Kubernetes.
It is an enterprise platform built on top of Kubernetes.

::: {.notes}
Explain that OpenShift adds security, developer experience, operators, registry, routes, monitoring, and enterprise lifecycle management.

Render:

```bash
quarto preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
Code language: JavaScript (javascript)

16. Sample Marp Slide File

Create:

Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Code language: CSS (css)

Content:

---
marp: true
theme: default
paginate: true
footer: "DevOpsSchool"
---

# Introduction to Red Hat OpenShift

## DevOpsSchool Training

---

# What is OpenShift?

Red Hat OpenShift is an enterprise Kubernetes platform.

It helps teams build, deploy, run, and manage containerized applications.

---

# Why OpenShift?

- Enterprise Kubernetes platform
- Built-in developer experience
- Integrated CI/CD support
- Strong security model
- Operator-based automation
- Hybrid cloud support

---

# Kubernetes vs OpenShift

| Area | Kubernetes | OpenShift |
|---|---|---|
| Type | Container orchestration | Enterprise Kubernetes platform |
| Security | Configurable | Strong defaults |
| Developer tools | External | Built-in |
| Registry | External | Integrated |
| Routes | Not native | Built-in |

---

# OpenShift Architecture

![width:900px](images/openshift-architecture.png)

---

![bg right:45%](images/openshift-logo.png)

# OpenShift CLI

```bash
oc get pods -A
oc get projects
oc get routes -A
Code language: PHP (php)

Preview:

```bash
npx @marp-team/marp-cli --preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Code language: JavaScript (javascript)

Generate PPTX:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pptx --allow-local-files
Code language: CSS (css)

17. Can You Embed Images?

Yes.

Both Quarto and Marp support images.

Recommended folder:

course/
├── course-topic.qmd
├── course-topic.marp.md
└── images/
    ├── architecture.png
    ├── lifecycle.png
    └── logo.png

Quarto image

![](images/openshift-architecture.png)

Marp image

![width:900px](images/openshift-architecture.png)

Marp background image

![bg right:45%](images/openshift-logo.png)

# OpenShift Architecture

Enterprise Kubernetes platform.
Code language: PHP (php)

For courses, use local images instead of remote URLs.

Bad for long-term course reliability:

![](https://example.com/image.png)
Code language: JavaScript (javascript)

Better:

![](images/image.png)

Why?

Because remote URLs can break. Local images make your course portable and stable.

18. Quarto Output Commands

From your slides folder:

cd ~/slides

Preview:

quarto preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
Code language: CSS (css)

Generate reveal.js HTML:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to revealjs
Code language: CSS (css)

Generate PPTX:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to pptx
Code language: CSS (css)

Generate PDF:

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to pdf
Code language: CSS (css)

19. Marp Output Commands

From your slides folder:

cd ~/slides

Preview:

npx @marp-team/marp-cli --preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Code language: CSS (css)

Generate HTML:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --html --allow-local-files
Code language: CSS (css)

Generate PDF:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pdf --allow-local-files
Code language: CSS (css)

Generate PPTX:

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pptx --allow-local-files
Code language: CSS (css)

20. One Automation Script to Build Both Quarto and Marp

Create:

build.sh
Code language: CSS (css)

Content:

#!/usr/bin/env bash
set -euo pipefail

mkdir -p output/quarto output/marp

QMD="Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd"
MARP="Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md"

echo "Building Quarto reveal.js HTML..."
quarto render "$QMD" --to revealjs --output-dir output/quarto

echo "Building Quarto PPTX..."
quarto render "$QMD" --to pptx --output-dir output/quarto

echo "Building Marp HTML..."
npx @marp-team/marp-cli "$MARP" --html --allow-local-files -o output/marp/openshift-marp.html

echo "Building Marp PDF..."
npx @marp-team/marp-cli "$MARP" --pdf --allow-local-files -o output/marp/openshift-marp.pdf

echo "Building Marp PPTX..."
npx @marp-team/marp-cli "$MARP" --pptx --allow-local-files -o output/marp/openshift-marp.pptx

echo "Done."
ls -lh output/quarto output/marp
Code language: PHP (php)

Run:

chmod +x build.sh
./build.sh

This gives you both Quarto and Marp outputs side by side.

21. Quarto Project Configuration

For serious course automation, create:

_quarto.yml
Code language: CSS (css)

Example:

project:
  type: website
  output-dir: output/site

format:
  revealjs:
    theme: [simple, css/reveal.scss]
    slide-number: true
    transition: slide
    logo: images/devopsschool-logo.png
    footer: "DevOpsSchool"
  pptx:
    reference-doc: templates/devopsschool-reference.pptx
Code language: JavaScript (javascript)

Now you can standardize:

• logo
• footer
• slide number
• fonts
• brand color
• theme
• PPTX template

This is very useful when you have many courses.

22. Marp Front Matter Configuration

Example:

---
marp: true
theme: default
paginate: true
footer: "DevOpsSchool"
---
Code language: JavaScript (javascript)

You can also use custom classes:

<!-- _class: lead -->

# OpenShift Training
Code language: HTML, XML (xml)

And custom backgrounds:

![bg](images/title-background.png)

# Red Hat OpenShift
Code language: PHP (php)

Marp is excellent for clean, direct visual control.

23. Branding Strategy

For a training business like DevOpsSchool, branding consistency is very important.

You should standardize:

• logo
• title slide
• section divider slide
• footer
• slide number
• instructor name
• website URL
• course category
• certificate/training brand identity

Recommended rule:

Use Quarto theme for main course system.
Use Marp CSS theme for quick PPTX/PDF decks.
Keep images and logos in a shared assets folder.
Code language: PHP (php)

Example shared structure:

shared-assets/
├── logos/
│   ├── devopsschool-logo.png
│   └── cotocus-logo.png
├── backgrounds/
│   ├── title-bg.png
│   └── section-bg.png
└── css/
    ├── reveal.scss
    └── marp-theme.css

24. Best Workflow for Educators

The recommended workflow is:

1. Write course content in Markdown / Quarto
2. Keep images in local folder
3. Use reusable templates
4. Render slides automatically
5. Export HTML/PDF/PPTX
6. Store everything in Git
7. Use CI/CD for automatic publishing
Code language: PHP (php)

Example:

Git push
   ↓
Build script runs
   ↓
Quarto generates HTML slides
   ↓
Quarto generates PDF/PPTX
   ↓
Marp generates quick PPTX/PDF if needed
   ↓
Output published to website or shared folder

This is how you scale course production.

25. Recommended CI/CD Pipeline

A simple GitHub Actions workflow may look like this:

name: Build Course Slides

on:
  push:
    branches:
      - main

jobs:
  build-slides:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Quarto
        uses: quarto-dev/quarto-actions/setup@v2

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 22

      - name: Install Marp CLI
        run: npm install -g @marp-team/marp-cli

      - name: Build Slides
        run: |
          chmod +x build.sh
          ./build.sh

      - name: Upload Output
        uses: actions/upload-artifact@v4
        with:
          name: course-output
          path: output/
Code language: HTTP (http)

This allows you to generate slides automatically every time you update the course.

26. Best Use Cases for Quarto

Use Quarto when you want:

• long-term course platform
• interactive HTML slides
• reveal.js output
• speaker notes
• course website
• student handouts
• labs
• documentation
• code-heavy lessons
• technical training
• Git-based automation
• reusable templates
• multi-output publishing

Best examples:

Kubernetes course
OpenShift course
Terraform course
Ansible course
Docker course
Jenkins course
GitLab CI/CD course
DevOps course
SRE course
AIOps course
MLOps course
CloudOps course

Quarto is especially good when your content includes:

• commands
• YAML files
• architecture diagrams
• labs
• code examples
• tables
• notes
• explanations
• lifecycle diagrams

27. Best Use Cases for Marp

Use Marp when you want:

• quick Markdown slides
• fast PDF export
• fast PPTX export
• simple corporate decks
• single-topic training slides
• static presentation files
• image-heavy slide decks
• quick instructor notes
• lightweight slide generation

Best examples:

30-minute overview deck
Sales/intro deck
Workshop opening slides
Quick DevOps topic slides
Interview preparation slides
Client-specific PPTX
Simple PDF handout slides

Marp is very efficient when you need:

write markdown quickly → generate PPTX/PDF quickly

28. When Not to Use Quarto

Do not use Quarto if:

• you want the simplest possible slide tool
• you only need one small PPTX
• you dislike configuration
• you do not need HTML/reveal.js
• you do not need documentation or course website output
• you want PowerPoint-style manual editing as the main workflow

In those cases, Marp may be easier.

29. When Not to Use Marp

Do not use Marp as your main system if:

• you want a full course platform
• you need reveal.js slides
• you need website + slides + notes
• you need advanced interactivity
• you need code execution
• you need reusable documentation workflows
• you want one source to become many content types

In those cases, Quarto is better.

30. Common Mistake: Trying to Force Marp into reveal.js

Marp does not directly export to reveal.js.

This is important.

Marp can create HTML slides, but that HTML is Marp’s own slide output, not reveal.js.

So avoid this mental model:

Marp Markdown → reveal.js
Code language: CSS (css)

Instead, use:

Quarto → reveal.js
Marp → HTML/PDF/PPTX/images

Correct decision:

Need reveal.js? Use Quarto.
Need quick PPTX/PDF? Use Marp.
Code language: PHP (php)

31. Common Mistake: Using PowerPoint as Master Source

PowerPoint is not bad.

But it should not be your master source for a large automated course system.

Better strategy:

Quarto/Markdown = master source
PowerPoint = export or final polish
Code language: JavaScript (javascript)

Why?

Because text files are easier to:

• version-control
• search
• reuse
• automate
• generate
• update
• review
• maintain

PowerPoint is better for final manual design, not large-scale content automation.

32. Practical Testing Plan

If you have both files:

Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md
Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd
Code language: CSS (css)

Test both.

Step 1: Generate Quarto Output

cd ~/slides

quarto preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to revealjs

quarto render Introduction_to_Red_Hat_OpenShift_DevOpsSchool.qmd --to pptx

Step 2: Generate Marp Output

cd ~/slides

npx @marp-team/marp-cli --preview Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --html --allow-local-files

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pdf --allow-local-files

npx @marp-team/marp-cli Introduction_to_Red_Hat_OpenShift_DevOpsSchool.marp.md --pptx --allow-local-files

Step 3: Compare

Ask these questions:

Which HTML looks better?
Which PPTX opens better?
Which PDF is cleaner?
Which source file is easier to edit?
Which one handles images better?
Which one is better for teaching?
Which one is easier to automate?
Which one can scale to 100 courses?

This test will give you a practical answer.

33. Recommended Standard for DevOpsSchool

For DevOpsSchool or any technical training platform, I recommend this rule:

Default: Quarto
Quick deck: Marp
Final client editing: PowerPoint
Code language: PHP (php)

More clearly:

34. Suggested Naming Convention

Use consistent file names.

Bad:

slides1.qmd
final-new-latest-v2.pptx
course-updated-final-final.md
Code language: PHP (php)

Good:

01-introduction-to-openshift.qmd
02-openshift-architecture.qmd
03-openshift-installation.qmd
04-openshift-projects-and-routes.qmd
05-openshift-deployment-lifecycle.qmd
Code language: CSS (css)

For Marp:

01-introduction-to-openshift.marp.md
Code language: CSS (css)

For output:

openshift-introduction.html
openshift-introduction.pdf
openshift-introduction.pptx
Code language: CSS (css)

35. Course Content Design Pattern

For every technical topic, use this slide structure:

1. Title
2. What is it?
3. Why is it needed?
4. Where is it used?
5. When should you use it?
6. How does it work?
7. Architecture
8. Lifecycle
9. Hands-on example
10. Common errors
11. Troubleshooting
12. Best practices
13. Interview questions
14. Summary
Code language: PHP (php)

This structure is excellent for topics like:

• Kubernetes Pod
• Kubernetes Deployment
• OpenShift Route
• Terraform Module
• Ansible Playbook
• Docker Image
• Jenkins Pipeline
• GitLab CI/CD
• Helm Chart
• Argo CD Application

Example:

Kubernetes Pod
├── What is a Pod?
├── Why do we need Pod?
├── Where is Pod used?
├── When should we create Pod directly?
├── Pod lifecycle
├── Pod YAML example
├── Pod troubleshooting
├── Pod best practices
└── Pod interview questions
Code language: JavaScript (javascript)

This is the “what, why, where, when, how, lifecycle” teaching rule.

36. Best Slide Strategy for Technical Courses

For technical education, every slide should not be just bullets.

Use a mix of:

• concept slides
• diagram slides
• command slides
• YAML/code slides
• comparison tables
• lifecycle slides
• troubleshooting slides
• quiz slides
• recap slides

Example course module:

Slide 1: Title
Slide 2: Learning objectives
Slide 3: What is OpenShift?
Slide 4: Kubernetes vs OpenShift
Slide 5: Architecture diagram
Slide 6: Login using oc CLI
Slide 7: Projects and namespaces
Slide 8: Deploy sample app
Slide 9: Expose app using route
Slide 10: Troubleshooting route issue
Slide 11: Best practices
Slide 12: Summary

This makes the course practical and memorable.

37. Recommended Slide Design Rules

Use these rules:

One concept per slide
Use diagrams where possible
Avoid too much text
Use large fonts
Use consistent colors
Use local images
Use speaker notes for teaching details
Use code blocks only when necessary
Use tables for comparison
Use lifecycle diagrams for process
Use summary slides after every major topic
Code language: PHP (php)

Bad slide:

Too many bullets
Too much text
No visual hierarchy
No diagram
No practical example

Good slide:

Clear title
Short explanation
Diagram
Command/example
One takeaway

38. How to Use Images Correctly

Recommended image folder:

images/
├── openshift-logo.png
├── openshift-architecture.png
├── kubernetes-vs-openshift.png
├── pod-lifecycle.png
└── route-flow.png

In Quarto:

![](images/openshift-architecture.png)

In Marp:

![width:900px](images/openshift-architecture.png)

In Marp background layout:

![bg right:40%](images/openshift-logo.png)

# Red Hat OpenShift

Enterprise Kubernetes platform.
Code language: PHP (php)

Best practice:

Use PNG/SVG for diagrams
Use JPG/WebP for photos
Use local images
Compress large images
Use consistent aspect ratio
Avoid copyrighted images without permission
Code language: PHP (php)

39. How to Handle Diagrams

For diagrams, you can use:

• PNG exports from diagram tools
• SVG diagrams
• Mermaid diagrams
• Draw.io diagrams exported as PNG/SVG
• Excalidraw diagrams
• architecture icons

For automation, the safest method is:

Create diagram → export as PNG/SVG → include in slides
Code language: JavaScript (javascript)

This works reliably in both Quarto and Marp.

40. Speaker Notes Strategy

Speaker notes are very important for trainers.

Use notes for:

• what to explain verbally
• examples to say live
• common student confusion
• troubleshooting tips
• real-world stories
• interview points
• transition notes

In Quarto:

## What is OpenShift?

OpenShift is an enterprise Kubernetes platform.

::: {.notes}
Explain that OpenShift is Kubernetes plus enterprise features such as routes, operators, security, registry, monitoring, and developer tools.
:::
Code language: PHP (php)

Speaker notes let you keep the slide clean while retaining teaching depth.

41. PPTX Strategy

Many clients still ask for PowerPoint.

So your automation system should support PPTX.

Recommended approach:

Create master in Quarto
Export PPTX when needed
Use Marp for quick PPTX-heavy decks
Use PowerPoint only for final client-specific polish
Code language: PHP (php)

PowerPoint should be treated as an output, not the source.

42. PDF Strategy

PDF is best for:

• student handouts
• offline sharing
• printable training material
• course download
• LMS upload
• email attachments

Use:

quarto render course.qmd --to pdf
Code language: CSS (css)

or:

npx @marp-team/marp-cli course.marp.md --pdf --allow-local-files
Code language: CSS (css)

For handout-style documents, Quarto is better.

For slide-style PDFs, both are good.

43. HTML Strategy

HTML is best for:

• web-based course slides
• online teaching
• self-paced learning
• hosting on your website
• sharing links
• mobile/tablet access
• interactive presentations

For HTML, use Quarto reveal.js:

quarto render course.qmd --to revealjs
Code language: CSS (css)

This is one of the strongest reasons to choose Quarto.

44. Recommended Tool Stack

For a professional educator automation system:

Authoring: Quarto
Slide engine: reveal.js
Quick slide export: Marp
Version control: Git
Automation: Shell script
CI/CD: GitHub Actions / GitLab CI
Images: local images folder
Diagrams: Draw.io / Excalidraw / Mermaid exported to PNG/SVG
Final editing: PowerPoint only when needed
Hosting: GitHub Pages / Netlify / Cloudflare Pages / own website
Code language: JavaScript (javascript)

45. Best Practical Setup for Rajesh / DevOpsSchool

Recommended:

DevOpsSchool Courses Repository
├── kubernetes/
├── openshift/
├── docker/
├── terraform/
├── ansible/
├── jenkins/
├── gitlab-ci/
├── sre/
├── devops/
├── aiops/
└── shared-assets/

Each course:

openshift/
├── _quarto.yml
├── slides/
├── labs/
├── notes/
├── images/
├── output/
└── build.sh

This setup can scale to hundreds of courses.

46. Example Build Script for Multiple Courses

#!/usr/bin/env bash
set -euo pipefail

COURSES=("openshift" "kubernetes" "docker" "terraform")

for COURSE in "${COURSES[@]}"; do
  echo "Building course: $COURSE"

  cd "$COURSE"

  mkdir -p output/html output/pptx output/pdf

  for FILE in slides/*.qmd; do
    echo "Rendering $FILE to reveal.js"
    quarto render "$FILE" --to revealjs --output-dir output/html

    echo "Rendering $FILE to PowerPoint"
    quarto render "$FILE" --to pptx --output-dir output/pptx
  done

  cd ..
done

echo "All courses built successfully."
Code language: PHP (php)

47. Recommended Course Lifecycle

Use this lifecycle:

Plan topic
   ↓
Create outline
   ↓
Write .qmd source
   ↓
Add images and diagrams
   ↓
Add code examples
   ↓
Add speaker notes
   ↓
Render HTML/PDF/PPTX
   ↓
Review
   ↓
Publish
   ↓
Update version

This is much better than editing PowerPoint repeatedly.

48. Version Control Strategy

Use Git branches:

main
develop
course/openshift-update
course/kubernetes-v2

Use commits like:

Add OpenShift architecture slides
Update Kubernetes pod lifecycle diagram
Fix Terraform module examples
Add speaker notes for Jenkins pipeline
Code language: JavaScript (javascript)

This makes your course development professional.

49. Course Versioning Strategy

Use version numbers:

OpenShift Course v1.0
OpenShift Course v1.1
OpenShift Course v2.0
Code language: CSS (css)

Example:

---
title: "Introduction to Red Hat OpenShift"
subtitle: "DevOpsSchool Training"
author: "Rajesh Kumar"
date: "2026-06-23"
version: "1.0"
---
Code language: JavaScript (javascript)

This helps when courses are updated over time.

50. Best Practice: Create Reusable Templates

Create reusable templates for:

• title slide
• agenda slide
• section divider
• architecture slide
• comparison slide
• lifecycle slide
• command slide
• YAML slide
• quiz slide
• summary slide

Example template pattern:

templates/
├── title-slide.qmd
├── agenda-slide.qmd
├── comparison-slide.qmd
├── lifecycle-slide.qmd
├── command-slide.qmd
└── summary-slide.qmd

This makes slide creation much faster.

51. Example Course Slide Template

---
title: "{{COURSE_TITLE}}"
subtitle: "{{COURSE_SUBTITLE}}"
author: "{{INSTRUCTOR_NAME}}"
format:
  revealjs:
    theme: simple
    slide-number: true
---

# {{COURSE_TITLE}}

## {{COURSE_SUBTITLE}}

---

## Learning Objectives

By the end of this module, you will understand:

- {{OBJECTIVE_1}}
- {{OBJECTIVE_2}}
- {{OBJECTIVE_3}}

---

## What is {{TOPIC}}?

{{SHORT_DEFINITION}}

---

## Why {{TOPIC}} is Needed?

- {{POINT_1}}
- {{POINT_2}}
- {{POINT_3}}

---

## How {{TOPIC}} Works

![](images/{{TOPIC_IMAGE}})

---

## Example

```bash
{{COMMAND_EXAMPLE}}
Code language: PHP (php)

Summary

• {{SUMMARY_1}}
• {{SUMMARY_2}}
• {{SUMMARY_3}}

---

# 52. AI-Assisted Slide Creation Workflow

Since educators now use AI heavily, the best workflow is:

```text
Ask AI to create outline
Review outline
Ask AI to create .qmd slides
Add diagrams/images
Review technical accuracy
Render slides
Manually improve examples
Publish
Code language: PHP (php)

Prompt example:

Create a Quarto reveal.js slide deck on Kubernetes Pod.
Include what, why, where, when, how, lifecycle, YAML example, troubleshooting, best practices, and interview questions.
Use educator-friendly language.
Output in .qmd format.
Code language: CSS (css)

This can speed up slide creation massively.

53. Quality Checklist Before Publishing

Before publishing any generated slide deck, check:

Does the first slide clearly define the topic?
Is there an agenda?
Are learning objectives clear?
Is every concept explained with examples?
Are diagrams readable?
Are commands tested?
Are YAML examples valid?
Are images local?
Are speaker notes useful?
Does PDF export work?
Does PPTX export open correctly?
Does HTML slide navigation work?
Is branding consistent?
Are file names clean?
Code language: JavaScript (javascript)

This checklist prevents low-quality course output.

54. Troubleshooting Quarto

Problem: quarto: command not found

Fix:

brew install --cask quarto
quarto --version

Problem: Image not showing

Check:

Is the image path correct?
Is image inside images/ folder?
Are you running command from correct folder?
Is the filename case-sensitive?
Code language: JavaScript (javascript)

Example:

![](images/openshift-architecture.png)

Problem: PPTX output looks different

PPTX output may not match HTML perfectly.

Fix:

Use custom PowerPoint reference template
Simplify slide layout
Avoid complex web-only effects
Use standard fonts
Test PPTX early
Code language: PHP (php)

Problem: PDF generation fails

Check whether your environment supports required PDF engine/browser setup.

55. Troubleshooting Marp

Problem: marp: command not found

Use:

npx @marp-team/marp-cli --version
Code language: CSS (css)

Or fix PATH:

npm config get prefix
echo 'export PATH="$(npm config get prefix)/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
rehash
Code language: JavaScript (javascript)

Problem: PDF/PPTX export fails

Install Chromium dependency:

npx playwright install chromium

Then rerun:

npx @marp-team/marp-cli course.marp.md --pdf --allow-local-files
npx @marp-team/marp-cli course.marp.md --pptx --allow-local-files
Code language: CSS (css)

Problem: Local images not loading

Use:

--allow-local-files

Example:

npx @marp-team/marp-cli course.marp.md --pdf --allow-local-files
Code language: CSS (css)

Problem: Image path wrong

Use:

images/file-name.png

not:

/Users/rajesh/Desktop/file-name.png

Relative paths are better.

56. Recommended Rule for Choosing Quarto or Marp

Use this simple rule:

If the content is part of a course library, use Quarto.
If the content is a quick standalone deck, use Marp.
Code language: PHP (php)

Another rule:

Need reveal.js or course website? Quarto.
Need quick PPTX/PDF? Marp.
Need both? Use Quarto as master and Marp for special quick decks.
Code language: JavaScript (javascript)

57. Final Verdict

For an educator who wants automation, reusability, web publishing, PDF handouts, and long-term course management:

Quarto is the best primary choice.

For someone who wants simple Markdown-to-PPTX/PDF slides quickly:

Marp is excellent.

For a serious training business:

Use Quarto as the main system.
Use Marp as a supporting tool.
Use PowerPoint only for final manual editing.
Code language: JavaScript (javascript)

58. Final Recommended Architecture

Master source: Quarto .qmd
Slide engine: reveal.js
Quick deck tool: Marp
Output formats: HTML, PDF, PPTX
Image storage: local images folder
Automation: build.sh
Version control: Git
Publishing: CI/CD
Final editing: PowerPoint only when required
Code language: PHP (php)

This gives you the best balance of:

• automation
• professional output
• scalability
• course reuse
• technical teaching support
• client compatibility
• future-proof publishing

59. Final One-Line Answer

If you are an educator and want to automate slide creation seriously:

Go with Quarto as your main platform, and keep Marp as a fast secondary tool for simple PPTX/PDF slide decks.
Code language: JavaScript (javascript)

That is the best long-term decision.
:::

Rajesh Kumar

I’m a DevOps/SRE/DevSecOps/Cloud Expert passionate about sharing knowledge and experiences. I have worked at Cotocus. I share tech blog at DevOps School, travel stories at Holiday Landmark, stock market tips at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow , and SEO strategies at Wizbrand.

Do you want to learn Quantum Computing?

Please find my social handles as below;

Rajesh Kumar Personal Website
Rajesh Kumar at YOUTUBE
Rajesh Kumar at INSTAGRAM
Rajesh Kumar at X
Rajesh Kumar at FACEBOOK
Rajesh Kumar at LINKEDIN
Rajesh Kumar at WIZBRAND

Rajesh Kumar DailyLogs