diff --git a/lightning-talks/Is-Historical-Data-an-Appropriate-Benchmark-For-Review-Recommendation-Systems.md b/lightning-talks/Is-Historical-Data-an-Appropriate-Benchmark-For-Review-Recommendation-Systems.md
index ae2086b..1b8dab2 100644
--- a/lightning-talks/Is-Historical-Data-an-Appropriate-Benchmark-For-Review-Recommendation-Systems.md
+++ b/lightning-talks/Is-Historical-Data-an-Appropriate-Benchmark-For-Review-Recommendation-Systems.md
@@ -7,5 +7,7 @@
 
 We find that history-based evaluation is far more pessimistic than optimistic in the context of Gerrit review recommendations. We find that in a majority of cases (74%), changes labeled as ‘incorrect’ by historical data were actually apt suggestions for reviewers.
 
+- Slides (TO BE PUBLISHED)
+- [Video](https://youtu.be/UcpU8m0awE8)
 
 *[Ian Gauthier, Flywheel.io](../speakers.md#igauthier)*
diff --git a/lightning-talks/forward-gerrit-events-to-jenkins-via-aws-kinesis.md b/lightning-talks/forward-gerrit-events-to-jenkins-via-aws-kinesis.md
index a1f3a0c..f167562 100644
--- a/lightning-talks/forward-gerrit-events-to-jenkins-via-aws-kinesis.md
+++ b/lightning-talks/forward-gerrit-events-to-jenkins-via-aws-kinesis.md
@@ -21,4 +21,7 @@
 > - loosing events when Jenkins restarts
 > - difficult to debug issues
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/Virtual%20Gerrit%20Summit%202021_%20Forward%20Gerrit%20events%20to%20Jenkins%20via%20AWS%20Kinesis.pdf)
+- [Video](https://youtu.be/XLuL-EKFRbc)
+
 *[Fabio Ponciroli, GerritForge](../speakers.md#fponciroli)*
diff --git a/lightning-talks/gerrithub-and-github-actions.md b/lightning-talks/gerrithub-and-github-actions.md
index f161f52..269540c 100644
--- a/lightning-talks/gerrithub-and-github-actions.md
+++ b/lightning-talks/gerrithub-and-github-actions.md
@@ -7,4 +7,7 @@
 process, and show how we use CUE to manage our GitHub Actions workflow
 configurations instead of Yaml.
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/2021-12-01%20Using%20GitHub%20Actions%20with%20GerritHub.pdf)
+- [Video](https://youtu.be/2B2PZTZlPJg)
+
 *[Paul Jolly, CUE](../speakers.md#myitcv)*
diff --git a/sessions/2.7-to-3.4-upgrade-improvements.md b/sessions/2.7-to-3.4-upgrade-improvements.md
index b267da7..08aaae6 100644
--- a/sessions/2.7-to-3.4-upgrade-improvements.md
+++ b/sessions/2.7-to-3.4-upgrade-improvements.md
@@ -8,6 +8,10 @@
 more detail on specific improvements. We'll also cover planned future
 work in this area.
 
+- [Slides](https://docs.google.com/presentation/d/e/2PACX-1vSvx4QUCv9B2Fv0Ezqa9Xjz7swmTja6g1iDcI5y7IM1wF1d6QwuZNGOfRjTqty3fA/pub)
+- [Video](https://youtu.be/V5QVf4DWUZ8)
+
 *[Martin Fick, Qualcomm, Gerrit Maintainer](../speakers.md#mfick)*
 *[Kaushik Lingarkar, Qualcomm](../speakers.md#kaushikl)*
 *[Adithya Chakilam, Qualcomm](../speakers.md#achakila)*
+*[Nasser Grainawi, Qualcomm, Gerrit Maintainer](../speakers.md#nasserg)*
\ No newline at end of file
diff --git a/sessions/checks-ui.md b/sessions/checks-ui.md
index eafbf7d..8fee421 100644
--- a/sessions/checks-ui.md
+++ b/sessions/checks-ui.md
@@ -18,5 +18,8 @@
 > - Somewhat addressing our needs.
 > - Not addressing our needs at all.
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/Checks%20UI%20-%20Slides.pdf)
+- [Video](https://youtu.be/IQO_wbtVKp4)
+
 *[Delphine Carlson, Google](../speakers.md#delphinec)*
 *[Ben Rohlfs, Google](../speakers.md#brohlfs)*
\ No newline at end of file
diff --git a/sessions/code-owners.md b/sessions/code-owners.md
index 4e19531..932834a 100644
--- a/sessions/code-owners.md
+++ b/sessions/code-owners.md
@@ -5,5 +5,8 @@
 
 In this talk, I'll demo the code owners functionality.
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/Code%20Owners_Demo.pdf)
+- [Video](https://youtu.be/p6kbDEipjCY)
+
 *[Edwin Kempin, Google](../speakers.md#edwin-kempin)*
 
diff --git a/sessions/gerrit-3.4-3.5.md b/sessions/gerrit-3.4-3.5.md
index 9c60158..c481141 100644
--- a/sessions/gerrit-3.4-3.5.md
+++ b/sessions/gerrit-3.4-3.5.md
@@ -41,5 +41,8 @@
 > - Lack of support during the upgrade
 > - Breaking changes
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/Whats.New.in.Gerrit.3.4-and.3.5.pdf)
+- [Video](https://youtu.be/3_ZFLSSBd3I)
+
 *[Luca Milanesio, GerritForge, Gerrit Maintainer - Release Manager - Member of the ESC](../speakers.md#lmilanesio)*
 *[Milutin Kristofic, Google](../speakers.md#milutin)*
diff --git a/sessions/mono-repo-with-gerrit.md b/sessions/mono-repo-with-gerrit.md
index b96210f..856d532 100644
--- a/sessions/mono-repo-with-gerrit.md
+++ b/sessions/mono-repo-with-gerrit.md
@@ -29,4 +29,7 @@
 > - long replication times
 > - batch reindexing tasks piling up
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/TracklingMonoRepos-with-Gerrit.pdf)
+- [Video](https://youtu.be/eANday2TsOk)
+
 *[Luca Milanesio, GerritForge, Gerrit Maintainer - Release Manager - Member of the ESC](../speakers.md#lmilanesio)*
diff --git a/sessions/overview-of-gerrit-in-aws.md b/sessions/overview-of-gerrit-in-aws.md
index 5df74d4..c43edbc 100644
--- a/sessions/overview-of-gerrit-in-aws.md
+++ b/sessions/overview-of-gerrit-in-aws.md
@@ -10,4 +10,7 @@
 usage and provide an overview of its current status. In the second part, we will
 showcase and live demo some of AWS-Gerrit main features.
 
-*[Antonio Barone, GerritForge](../speakers.md#syntonyze)*
\ No newline at end of file
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/Overview%20of%20Gerrit%20in%20AWS-03-12-2021.pdf)
+- [Video](https://youtu.be/FSH0wykytG8)
+
+*[Antonio Barone, GerritForge](../speakers.md#syntonyze)*
diff --git a/sessions/promoting-situational-awareness-in-code-review.md b/sessions/promoting-situational-awareness-in-code-review.md
index d6317b7..d175f5c 100644
--- a/sessions/promoting-situational-awareness-in-code-review.md
+++ b/sessions/promoting-situational-awareness-in-code-review.md
@@ -2,4 +2,7 @@
 
 While code review is a popular practice that has several reported benefits in the literature, it's still largely based on the sleuth work of developers based on textual codebase differences. In this talk, I will introduce the research that my group ([the Software REBELs](https://rebels.cs.uwaterloo.ca/)) is working on to incorporate additional perspectives (e.g., build-time, historical, operational, concurrent development) in the code review interface.
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/promoting-situational-awareness-code-review-platforms.pdf)
+- [Video](https://youtu.be/0K7G692MWjI)
+
 *[Shane McIntosh, University of Waterloo](../speakers.md#smcintosh)*
diff --git a/sessions/pull-replication-plugin.md b/sessions/pull-replication-plugin.md
index a9681e8..c13761e 100644
--- a/sessions/pull-replication-plugin.md
+++ b/sessions/pull-replication-plugin.md
@@ -24,4 +24,7 @@
 > - around 30 minutes
 > - over 30 minutes
 
+- [Slides](https://storage.googleapis.com/gerrit-talks/summit/2021/An%20Introduction%20to%20pull-replication%20plugin.pdf)
+- [Video](https://youtu.be/6rubGQE9v2E)
+
 *[Marcin Czech, GerritForge](../speakers.md#mczech)*
diff --git a/sessions/submit-requirements.md b/sessions/submit-requirements.md
index 23719b3..1a2252e 100644
--- a/sessions/submit-requirements.md
+++ b/sessions/submit-requirements.md
@@ -9,4 +9,7 @@
 In this talk, I'll demo the new submit requirements and talk about
 how you can wave goodbye to Prolog, too.
 
+- Slides (TO BE PUBLISHED)
+- [Video](https://youtu.be/AUtfUhBws9w)
+
 *[Patrick Hiesel, Google](../speakers.md#patrick-hiesel)*
diff --git a/speakers.md b/speakers.md
index dab4a97..f18d634 100644
--- a/speakers.md
+++ b/speakers.md
@@ -137,4 +137,10 @@
 
 Milutin joined the Gerrit frontend team in June 2019 and has been a maintainer
 since December 2020. Milutin was mostly working on better A11y and optimizing
-performance.
\ No newline at end of file
+performance.
+
+### Nasser Grainawi - Qualcomm {#nasserg}
+
+Nasser has been in the Gerrit world since 2008 and has been a maintainer since
+November 2020. He's the lead of the Qualcomm Gerrit team and has been a
+community manager since May 2021.
\ No newline at end of file
