diff --git a/sessions/checks-ui.md b/sessions/checks-ui.md
index dd22065..eafbf7d 100644
--- a/sessions/checks-ui.md
+++ b/sessions/checks-ui.md
@@ -4,5 +4,19 @@
 the change page. We will quickly walk you through the new user interface and
 explain how you can hook up your own CI systems with this new API.
 
+## Polls
+
+> ### How much of a pain point is Gerrit Checks/CI integration for you and your organization?
+> - Biggest pain point.
+> - One of the big pain points.
+> - Small pain point.
+> - Not much of an issue.
+
+> ### Will the demoed features address your and your organization's needs for Checks/CI integration?
+> - Fully addressing all our needs.
+> - Mostly addressing our needs.
+> - Somewhat addressing our needs.
+> - Not addressing our needs at all.
+
 *[Delphine Carlson, Google](../speakers.md#delphinec)*
 *[Ben Rohlfs, Google](../speakers.md#brohlfs)*
\ No newline at end of file
