diff --git a/docs/html/distribute/googleplay/edu/guidelines.jd b/docs/html/distribute/googleplay/edu/guidelines.jd
index 820cb17..c1d3065 100644
--- a/docs/html/distribute/googleplay/edu/guidelines.jd
+++ b/docs/html/distribute/googleplay/edu/guidelines.jd
@@ -107,13 +107,6 @@
   </li>
 </ul>
 
-<p>We discourage the use of ads within apps included in Google Play for Education.
-While ads are allowed, please note that the Google Play for Education site will
-flag apps that display ads, so educators can choose use apps that are ad-free.
-Similarly, we also discourage any UI within your app that exposes in-app purchase
-to students. <!--Please note that we may block access to in-app purchases on student
-tablets.--></p>
-
 
 <h2 id="approved">Educational Value</h2>
 
@@ -170,8 +163,8 @@
   <li>Meet Core app quality guidelines
     <ul>
       <li>Follow <a
-      href="{@docRoot}design/index.html">Android Design Guidelines</a>.
-      Pay special attention to the sections on <a href="{@docRoot}design/patterns/actionbar.html">Action
+      href="{@docRoot}design/index.html">Android Design Guidelines</a>. Pay special
+      attention to the sections on <a href="{@docRoot}design/patterns/actionbar.html">Action
       Bar</a>, <a href="{@docRoot}design/patterns/navigation.html">Navigation</a> and <a
       href="{@docRoot}design/patterns/pure-android.html">Pure Android</a>.</li>
       <li>Test your apps against the <a href="{@docRoot}distribute/googleplay/quality/core.html">Core
@@ -183,15 +176,16 @@
    <li>Follow our best practices for tablet app development</li>
    <li>Review the <a href="{@docRoot}distribute/googleplay/quality/tablet.html">Tablet App
    Quality Checklist</a> and <a
-   href="http://android-developers.blogspot.com/2012/11/designing-for-tablets-were-here-to-help.html" target="_android">blog post on designing for tablets</a></li>
+   href="http://android-developers.blogspot.com/2012/11/designing-for-tablets-were-here-to-help.html"
+   target="_android">blog post on designing for tablets</a></li>
    <li>Check your Optimization Tips in the Google Play Developer Console (if you've
    already uploaded your app)</li>
   </ul>
 <li>Strive for simplicity and highest usability for students
   <ul>
     <li>Design your app so that teachers and students can use all capabilities of
-    your app without
-    having to sign-in to multiple accounts and remember multiple passwords.</li>
+    your app without having to sign-in to multiple accounts and remember
+    multiple passwords.</li>
     <li>Every student or teacher using a Google Play for Education tablet will already be
     signed in with a Google account on the device.  You can take advantage of that to provide a
     simple, seamless sign-in experience in your app. A recommended approach is to use
@@ -216,10 +210,11 @@
 
 <h3 id="devices">Android tablets</h3>
 
-<p>Google Play for Education uses primarily Nexus 7 and Nexus 10 devices, so
-your testing can focus on those specific hardware devices. You can purchase the
-devices from <a href="https://play.google.com/store/devices/details?id=nexus_7_16gb" target="_android">Google Play</a> and other stores. Although testing on Nexus
-devices is preferred, you can test on other 7-inch or 10-inch tablets or virtual
+<p>Google Play for Education uses primarily Nexus 7 devices, so
+your testing can focus on that specific hardware device. You can purchase the
+device from <a href="https://play.google.com/store/devices/details?id=nexus_7_16gb"
+target="_android">Google Play</a> and other stores. Although testing on Nexus
+devices is preferred, you can test on other 7-inch (or 10-inch) tablets or virtual
 devices if you don't have access to Nexus devices.</p>
 
 <h3 id="conditions">Test conditions</h3>
diff --git a/docs/html/distribute/googleplay/edu/start.jd b/docs/html/distribute/googleplay/edu/start.jd
index 67055ba..419d5ea 100644
--- a/docs/html/distribute/googleplay/edu/start.jd
+++ b/docs/html/distribute/googleplay/edu/start.jd
@@ -228,26 +228,26 @@
 available, but will be available soon.</p>
 
 
-<h2 id="program">Google Play for Education Pilot Program</h2>
+<h2 id="program">Including Your Apps in the Pilot Program</h2>
 
-<p>Leading up to the full launch in Fall 2013, Google Play for Education will be
-available to participating schools across the United States as part of a pilot
-program. Educators in participating schools can browse for apps and purchase
-them in bulk, then deploy them instantly to teacher and student devices. </p>
+<p>Leading up to the Fall 2013 launch, the Google Play for Education team is
+conducting an extensive series of pilots that include schools and students across
+the United States. Educators in participating schools can browse for apps and
+purchase them in bulk, then deploy them instantly to teacher and student
+devices. </p>
 
-<h3 id="pilot-apps">Including your apps in the pilot</h3>
-
+<h3 id="pilot">Early opt-in and publishing</h3>
 <p>As an app developer, you can take part in the pilot program, getting your app
 into the hands of schools and key influencers in the education technology
-community. It's a great way to get early feedback on your educational app. To
-offer your app in the pilot program, just prepare the app, ensure that it meets the
-<a href="{@docRoot}distribute/googleplay/edu/guidelines.html">Guidelines for
-Apps</a>, and then opt-in to Google Play for Education, as described above.  </p>
+community. It's a great way to get early feedback on your educational app. </p>
 
-<p>Once your app is approved during review by our third-party educator network,
-it will be made available to educators in the pilot program right away. Note
-that, during the pilot program, the review and approval process may take longer
-than usual.</p>
+<p>To offer your app in the pilot program, prepare the app and ensure that it meets
+the <a href="{@docRoot}distribute/googleplay/edu/guidelines.html">Guidelines
+for Apps</a>. Then opt-in to Google Play for Education and publish as soon
+as you are ready. Once your app is approved during review by our third-party
+educator network, it will be made available to educators in the pilot program
+right away. Note that during the pilot program, the review and approval process
+may take longer than usual.</p>
 
 <h3 id="launch">Full launch to US schools</h3>
 <p>The initial launch of Google Play for Education is planned for Fall 2013. The
@@ -255,4 +255,10 @@
 with support for schools in other countries to follow. </p>
 
 <p>At this time, you should include your app in Google Play for Education only
-if it is targeting the US K-12 market. </p>
\ No newline at end of file
+if it is targeting the US K-12 market. </p>
+
+<h3 id="more">More information</h3>
+
+<p>If you'd like to be notified by email of the latest information about Google Play
+for Education, visit the <a href="{@docRoot}distribute/googleplay/edu/contact.html">
+Sign Up</a> page and fill out the form. </p>
\ No newline at end of file
