📊 Lesson 6.3: Version History, Embedding & Linking Sheets Charts

This lesson delivers two gifts. First, the safety net that makes all your bold experimenting fearless: version history, which quietly records every change so you can roll back time itself. Second, the Workspace glue — embedding a deck into a website or Doc, and the genuinely magical trick of dropping a live chart from Google Sheets into a slide that updates when your data does. By the end, your running deck will carry a live Sheets chart and you'll have watched its own history unfold.

📚 What You'll Learn

By the end of this lesson, you will be able to:

Open version history, read the timeline of who changed what, and restore an earlier version
Create named versions as milestones, and know when to make a copy instead
Embed a deck in a website or Google Doc so it lives inside another page
Insert a live chart from Google Sheets and Update it when the source data changes
Explain how this ties your deck to the Sheets and Docs courses as one connected Workspace

⏱️ Estimated Time: 40 minutes

🎯 Project: Link a live Google Sheets chart into your running deck (and practice the Update button), then open version history to see your deck's own timeline unfold.

In This Lesson

🕓 Version History: The Safety Net

Way back in Lesson 1.1 we promised you genuinely cannot break anything in Google Slides. This is the feature that makes that promise true. Every change you and your collaborators make is quietly recorded, and you can scroll back through the entire life of the deck to any earlier moment — and return to it.

Open it from File → Version history → See version history (there's also a keyboard shortcut and a "last edit" link near the menu bar). A panel opens on the right showing a timeline of versions, newest at the top. Click any entry and the main canvas shows the deck as it was at that moment. Because Slides is collaborative, each version is also tagged with who made the changes — color-coded by person — so on a shared deck you can see exactly who did what, and when.

This changes how you work. When you know every state is recoverable, you stop being timid. Want to try a bold new theme, delete half the slides to see if a shorter deck lands better, or let a teammate rework the whole flow? Do it. If it doesn't work, version history takes you right back. Fearless experimenting is the whole point — and it's exactly the growth-mindset habit this course keeps encouraging.

🧠 Mindset

Think of version history as an undo button that never expires and never forgets. Regular undo (Ctrl/Cmd+Z) only reaches back within your current session; version history reaches back across days, weeks, and every collaborator. Knowing the net is there is what lets a beginner experiment like an expert. Bravery in design isn't recklessness when nothing can truly be lost.

🏷️ Named Versions & Restoring

Slides saves versions automatically, but the automatic list can get long and anonymous — dozens of "September 15, 3:42 PM" entries. The fix is a named version: a milestone you label yourself so you can find it instantly later.

Creating a named version

Use File → Version history → Name current version, then give it a meaningful label: "First full draft," "After client feedback," "Final for Tuesday pitch." Named versions stand out in the timeline, so instead of hunting through timestamps you jump straight to the milestone that matters. It's the deck equivalent of dog-earing the important pages of a book.

Restoring an earlier version

Found the version you want back? Select it in the timeline and click Restore this version. The deck returns to that state — and, reassuringly, your restore is itself just another entry in the history. Restoring doesn't erase what came after; it adds a new "restored" version on top, so even the act of rolling back is reversible. You can always change your mind again.

✅ Pro Tip

Name a version at every real milestone — before a big redesign, right after incorporating feedback, the moment a deck is "done" for a given talk. Ten seconds of naming now saves ten minutes of squinting at timestamps later, and it turns your history into a clean, labeled story of the deck's life instead of an undifferentiated wall of autosaves.

⚠️ Important Note: Exact menu wording and the shortcut can shift as Google updates Slides. The durable idea is what matters: every change is recorded, you can name milestones, and you can restore any point non-destructively. Wherever the buttons move, look under the File menu for "Version history."

📄 Make a Copy vs Restore

Restoring rewinds the same deck. Sometimes you don't want to rewind — you want to branch. That's what File → Make a copy is for: it creates a brand-new, independent deck that starts as an exact duplicate of the current one, with its own version history from that point on.

Reach for "Make a copy" when you want to keep the original untouched and experiment on a clone: a variant of the pitch for a different audience, a template you'll reuse for next quarter, a risky redesign you want to compare side by side with the original. Reach for "Restore" when the one deck took a wrong turn and you simply want it back the way it was.

You want to…	Use	Result
Rewind this deck to an earlier state	Restore (version history)	Same deck, same link, rolled back — and the restore is itself reversible
Keep the original and experiment on a duplicate	Make a copy	A new, separate deck with its own history; the original is untouched
Reuse a finished deck as a starting point	Make a copy	A fresh deck to adapt, leaving the "final" version safe

💡 A copy is a fork; a restore is a rewind

If you're ever nervous about a big change on an important deck, "Make a copy" first, then go wild on the copy. But honestly, with version history in place you rarely need to — the same deck can be rewound at will. Save copies for when you genuinely want two decks, not one.

🌐 Embedding a Deck in a Site or Doc

Sometimes you want a deck to live inside another page rather than behind a link — right there in a blog post, a company website, a class portal, or a Google Doc. That's embedding, and it's how a slideshow becomes part of a bigger page.

Publish to the web & embed

Under File → Share → Publish to the web, Slides gives you an embed code (a small snippet you paste into a website's HTML) and options like auto-advancing slides and looping. Paste that snippet into a web page and the deck appears as a playable slideshow inside it. Note the honest caveat: publishing to the web makes the deck public — anyone who reaches that page can view it, outside your normal share list. Use it for content you're happy to show the world, not for anything sensitive.

Embedding in a Google Doc

You can also go the other way and put a slide inside a Google Doc: select the slide in the filmstrip, copy it (Ctrl+C / ⌘+C), paste it into the Doc, and choose Link to presentation when Docs asks, so it stays linked to the source deck. The pattern is the same one we're about to see with Sheets: one thing lives in a Doc but points back to the real deck, so it can be refreshed.

⚠️ Watch Out — embedding is more open than sharing

Sharing a link (Lesson 6.1) keeps a deck inside Slides' permission system — you set roles and can revoke access. Publishing to the web is fully public and lives outside that system. They look similar but they're not: one is a controlled guest list, the other is a page anyone can find. Choose deliberately, and never publish a deck that contains anything you wouldn't put on a public poster.

📈 Linking a Live Chart from Google Sheets

Here's the payoff feature — the one that makes people say "wait, it does that?" You can drop a chart from Google Sheets onto a slide and keep it linked to the spreadsheet, so when your data changes, one click brings the slide's chart up to date. Your slide always shows the latest numbers without you ever redrawing a chart.

How to do it

Build your chart in Google Sheets as normal (this is exactly what the Sheets course covers).
In Slides, go to Insert → Chart → From Sheets.
Pick the spreadsheet, then the specific chart within it.
Crucially, keep "Link to spreadsheet" checked, and insert. The chart lands on your slide, tethered to its source.

The "Update" button

Because it's linked, the chart shows a small Update button (or an "Update all" option) whenever the source data in Sheets has changed. Edit a number in the spreadsheet, click Update on the slide, and the chart redraws with the new figures — no re-inserting, no manual editing. This is enormous for any deck built on real data: a sales report, a budget, a survey, a KPI dashboard. Update the spreadsheet once, and every linked chart across your slides refreshes on demand.

graph LR A["📊 Google Sheets
your data & chart"] -- "Insert → Chart
→ From Sheets (linked)" --> B["🖼️ Linked chart
on your slide"] A -- "you edit the numbers" --> C["🔄 Data changed"] C --> D["🔘 'Update' button
appears on the slide"] D -- "one click" --> B B --> E["✅ Slide always shows
the latest figures"]

Notice what the diagram shows: the spreadsheet stays the single source of truth for the data, and the slide holds a live view of it. You never maintain the same numbers in two places. If you'd rather freeze a chart at a moment in time — say, for an archived report — you can instead insert it unlinked (uncheck "Link to spreadsheet"), and it becomes a static image that won't change. Linked for living data; unlinked for a snapshot.

✅ Pro Tip

Linked charts shine for recurring decks. A monthly team update, a quarterly board deck, a weekly metrics review — build the deck once with linked Sheets charts, and each period you just update the spreadsheet and click Update. The design work is done forever; only the data flows in. That's the moment a deck stops being a document and becomes a dashboard.

🧩 The Workspace Glue — One Connected System

Step back and notice what just happened. A chart born in Sheets now lives on a Slides slide, and could be surfaced again inside a Docs report — all pointing back to one source of truth, all refreshable with a click. That's the quiet superpower of Google Workspace: the apps aren't islands, they're a connected system, and the linked chart is the clearest example of the glue that binds them.

This is the exact skill that ties your three Google Workspace courses together. In the Google Sheets course you learned to build and chart data. In the Google Docs course you learned to write and link content. Here in Slides, you pull a live Sheets chart into a presentation. Learn one app and you're not learning a silo — you're learning a piece of a whole that works together, so the same data can flow into a report, a spreadsheet, and a pitch deck without ever being retyped.

💡 Honest comparison — the Microsoft world does this too

To be fair, Microsoft's ecosystem has the same idea: you can paste an Excel chart into PowerPoint and keep it linked, and Microsoft 365 ties Word, Excel, and PowerPoint together. The concept transfers cleanly both ways. Where Google shines is that it's all cloud-native and shareable with no setup — your linked chart works from any browser and updates for every collaborator at once. As always, the skill you're learning here makes you more capable in both worlds.

✅ Pro Tip

When you present data, resist screenshotting a chart into a slide. A screenshot is frozen the instant you take it and silently goes stale; a linked chart stays honest. If your deck lives on real numbers, link them — future-you, updating the deck five minutes before the meeting, will be grateful.

🎯 Project: Link a Chart & Explore History

Two things this lesson: you'll wire a live Sheets chart into your running deck and prove the Update loop works, then open version history to watch your deck's own timeline. One project shows off the Workspace glue; the other shows off the safety net.

🏋️ Link a chart, then read your deck's history

Objective: Insert a linked Google Sheets chart, update it from the source, and explore your deck's version history (naming and restoring).

Instructions (about 14 minutes):

(3 min) In Google Sheets, make a tiny table (e.g. three months and a number each) and insert a simple chart from it. No fancy data needed — anything works.
(3 min) In your running deck, add a slide and go to Insert → Chart → From Sheets. Choose your spreadsheet and chart, keep "Link to spreadsheet" checked, and insert it.
(2 min) Go back to Sheets and change one number. Return to the slide, find the Update button on the chart, and click it. Watch the chart redraw with the new figure — that's the live link working.
(2 min) Now open File → Version history → Name current version and label this milestone, e.g. "Added live Sheets chart."
(3 min) Open File → Version history → See version history. Scroll the timeline: notice the automatic versions, your named milestone, and (if you've collaborated) who made which changes. Click an older version to preview the deck as it was.
(1 min) Optional but reassuring: Restore an earlier version, confirm the restore itself appears as a new history entry, then restore back to your latest. Nothing is ever lost.

💡 Hint — the mental map for this project

WORKSPACE GLUE (the linked chart)
Sheets: data + chart
   |  Insert -> Chart -> From Sheets  (Link to spreadsheet = ON)
   v
Slide: linked chart
   |  change a number in Sheets
   v
Slide shows "Update" button -> click -> chart refreshes

SAFETY NET (version history)
File -> Version history -> Name current version   ("Added live Sheets chart")
File -> Version history -> See version history    (timeline + who changed what)
   -> pick a version -> Restore   (reversible: the restore is itself a new entry)

No spreadsheet data of your own? Use anything at all — favorite-snack counts, hours of sleep this week, made-up sales. The point is the link and the Update loop, not the numbers.

✅ Project Completion Checklist

A chart from Google Sheets is inserted on a slide with "Link to spreadsheet" on
You changed a number in Sheets and successfully used the Update button on the slide
You created a named version as a milestone
You opened version history and previewed at least one earlier version (bonus: restored and un-restored)
You can explain how the linked chart connects your Slides deck to the Sheets (and Docs) courses

🎯 Quick Quiz

Question 1: You inserted a Sheets chart with "Link to spreadsheet" checked, then later changed the numbers in the spreadsheet. How does the slide's chart show the new data?

Question 2: What's the honest difference between Restore (in version history) and Make a copy?

🧭 Best Practices for History & Linking

✅ Do's

Name versions at milestones. "First draft," "After feedback," "Final for Tuesday" turn a wall of autosaves into a story.
Link charts for living data. If a deck rests on real numbers, keep the Sheets link and use Update — never a screenshot that goes stale.
Experiment fearlessly. Version history has your back, so try the bold redesign.

❌ Don'ts

Don't confuse publishing to the web with sharing a link. Publishing is fully public and outside your share list.
Don't maintain the same numbers in two places. Let Sheets be the source of truth and link the chart.
Don't fear restoring. A restore is reversible — it's logged as a new entry, so you can always undo the undo.

💡 Pro Tips

For recurring decks (monthly, quarterly), build once with linked charts — then only the data flows in each cycle.
Make a copy when you want two decks; restore when you want the one deck back.

📓 Learning Journal

Keep a learning journal as you work through this course — a separate document, a note, or even a slide at the end of the deck you're building. After each lesson, take a few minutes to write down:

Key concepts you learned
Techniques that clicked for you
Questions or confusion points to revisit
Ideas you want to try in your own decks
Your progress and feelings about learning this — including where your confidence grew

✍️ This lesson's prompt: Now that you know version history exists, does it change how boldly you'd experiment with your deck's design? And think of a presentation you've given (or will give) that rests on data — where would a live, linked Sheets chart save you from redrawing or re-pasting? How does it feel to see Slides, Sheets, and Docs as one connected system rather than separate apps? Note one deck in your life that could become a reusable, data-linked "dashboard."

📝 Lesson Summary

🎓 Key Takeaways

Version history (File → Version history) records every change with a timeline of who did what, lets you create named versions as milestones, and lets you restore any point — non-destructively, since the restore is itself reversible.
Restore rewinds the same deck; Make a copy forks a new, independent deck so you can experiment or reuse without touching the original.
Embedding (Publish to the web) places a deck inside a website or Doc — but it's fully public, a more open thing than sharing a controlled link.
Linking a live Sheets chart (Insert → Chart → From Sheets, kept linked) puts real data on a slide you refresh with the Update button — the Workspace glue that ties your Slides, Sheets, and Docs work into one connected system.

🎉 What You've Accomplished

You've unlocked the safety net that makes fearless experimenting possible, and you've connected your deck to live data. Your running deck now carries a chart that updates from a spreadsheet with a click, you know how to name and restore versions, and you understand how embedding and linking make a deck part of the wider Workspace. That's the difference between a static slideshow and a living, connected presentation.

❓ Common Questions at This Stage

If I share my deck as a Viewer, can people see the version history?

No — version history is an editing/owner feature, not something viewers or commenters see. They only ever see the current state of the deck. Version history is your and your fellow editors' behind-the-scenes safety net, which is exactly as it should be.

Does a person need access to the Sheet for my linked chart to work?

For you to update the chart, you need access to the source spreadsheet. For your audience viewing the slide, the chart shows as an image of the latest data you updated — they don't need Sheet access just to see it. If collaborators will update the chart themselves, make sure they can open the underlying Sheet too, using the sharing skills from Lesson 6.1.

What's the safest way to try a risky redesign on an important deck?

You have two good options. Either name a version first ("Before redesign") and experiment on the same deck knowing you can restore, or make a copy and go wild on the duplicate while the original sits untouched. For most cases the named version is enough — version history means the one deck can always be rewound.

🔭 Looking Ahead

In the next lesson — Lesson 7.1: Project — A Pitch Deck — everything you've built comes together. You'll take the running deck you've grown across the whole course and shape it into a polished, complete pitch deck: message, structure, design, sharing, collaboration, and live data all in one real presentation. It's the payoff module, and you're fully equipped for it.

✅ Before the Next Lesson

Confirm your running deck has a live, linked Sheets chart on it
Name a "current" version so you have a clean milestone before the big project module
Write your Learning Journal entry for this lesson

📚 Additional Resources

🌟 Encouragement for the Journey

You just gained two of the most reassuring skills in the whole course: a time machine that means you can't truly break anything, and a live wire that keeps your data honest and your apps working as one. With the safety net under you and the Workspace glued together, there's nothing left to fear and everything left to build. Module 7 — your real pitch deck — is where it all comes together. Let's finish strong. 📊