diff --git a/src/compatibility/contact-us.jd b/src/compatibility/contact-us.jd
index f138dbb..b0d0a78 100644
--- a/src/compatibility/contact-us.jd
+++ b/src/compatibility/contact-us.jd
@@ -2,7 +2,7 @@
 @jd:body
 
 <!--
-    Copyright 2013 The Android Open Source Project     
+    Copyright 2015 The Android Open Source Project     
 
     Licensed under the Apache License, Version 2.0 (the "License");    
     you may not use this file except in compliance with the License.   
@@ -16,7 +16,7 @@
     See the License for the specific language governing permissions and    
     limitations under the License.   
 -->
-<p>Thanks for your interest in Android compatibility! This page describes the
+<p>This page describes the
 contact methods for inquiries regarding the Android compatibility program,
 including the Compatibility Definition Document (CDD) and Compatibility Test
 Suite (CTS). See the <a href="{@docRoot}community/index.html">Community</a>
@@ -37,18 +37,15 @@
 href="mailto:android-compatibility+subscribe@googlegroups.com">android-compatibility</a></li>
 </ul>
 
-<p>To make best use of this list, please first read <em>Getting the Most from
-Our Lists</em> on the <a href="{@docRoot}source/community/index.html">Community</a>
-page. Users looking for help with Android devices should contact their carrier
-or manufacturer for help.</p>
+<p>To make best use of this list, please first read <a
+href="{@docRoot}source/community/index.html#getting-the-most-from-our-lists">Getting
+the Most from Our Lists</a> on the Community page. Users looking for help with
+Android devices should contact their carrier or manufacturer for help.</p>
 
-<h2 id="for-business-inquiries">For business inquiries</h2>
-<p>Finally, business inquiries about the compatibility program, including
-requests to use branding elements and similar, can be sent to the address <a
+<h2 id="for-business-inquiries">For licensing Google Mobile Services</h2>
+<p>Business inquiries about licensing Google Mobile Services can be sent to <a
 href="mailto:android-partnerships@google.com">android-partnerships@google.com</a>.
-This address is for specific, private inquiries; general questions will be
-directed back to the android-compatibility list.</p>
 
 <p>While we read every email that
 is received at the android-partnerships alias, we cannot respond to each of them.
-Please note, we will be in contact if we can help you.</p>
+But we promise to contact you if we can help!</p>
diff --git a/src/compatibility/index.jd b/src/compatibility/index.jd
index 60c2951..b3c375a 100644
--- a/src/compatibility/index.jd
+++ b/src/compatibility/index.jd
@@ -2,7 +2,7 @@
 @jd:body
 
 <!--
-    Copyright 2013 The Android Open Source Project     
+    Copyright 2015 The Android Open Source Project     
 
     Licensed under the Apache License, Version 2.0 (the "License");    
     you may not use this file except in compliance with the License.   
@@ -64,9 +64,15 @@
 </li>
 </ol>
 
-<h2 id="joining-the-ecosystem">Joining the ecosystem</h2>
-<p>Once you've built a compatible device, you may wish to include Google
-Play to provide your users access to the third-party app ecosystem.
-Unfortunately, for a variety of legal and business reasons, we aren't able to
-automatically license Google Play to all compatible devices. To inquire
-about access to Google Play, you can <a href="contact-us.html">contact us</a>.</p>
+<p>After complying with the CDD and passing the CTS, your device is now Android
+compatible. Android apps in the ecosystem will have a consistent experience on
+your device.</p>
+
+<h2 id="licensing-gms">Licensing Google Mobile Services</h2>
+<p>If you've built an Android compatible device, you may wish to inquire about
+licensing Google’s proprietary suite of apps that run on top of Android -
+Google Mobile Services (GMS, which include Google Play, YouTube, Google Maps,
+Gmail, and more). Google Mobile Services is not part of the Android Open Source
+Project and is available only through a license with Google. Please visit the
+‘contact’ us section for more information on how to inquire about a GMS
+license.</p>
