diff --git a/docs/html/about/about_toc.cs b/docs/html/about/about_toc.cs
index 62d37c5..45e8eb3 100644
--- a/docs/html/about/about_toc.cs
+++ b/docs/html/about/about_toc.cs
@@ -1,11 +1,5 @@
 <ul id="nav">
 
-<li class="nav-section">
-    <div class="nav-section-header"><a href="<?cs var:toroot?>about/index.html">Welcome</a></div>
-    <ul>
-      <li><a href="<?cs var:toroot?>about/start.html">Get Started</a></li>
-    </ul>
-  </li>
   <li class="nav-section">
     <div class="nav-section-header"><a href="<?cs var:toroot ?>about/versions/lollipop.html"
               zh-tw-lang="Lollipop"
@@ -47,14 +41,20 @@
       </ul>
   </li>
 
-  <li class="nav-section">
+  <!-- <li class="nav-section">
     <div class="nav-section-header"><a href="<?cs var:toroot ?>about/versions/android-4.0-highlights.html">
       <span class="en">Ice Cream Sandwich</span></a></div>
       <ul>
         <li><a href="<?cs var:toroot ?>about/versions/android-4.0.3.html">Android 4.0.3 APIs</a></li>
         <li><a href="<?cs var:toroot ?>about/versions/android-4.0.html">Android 4.0 APIs</a> </li>
       </ul>
+  </li> -->
+
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs
+var:toroot?>about/android.html">About Android</a></div>
   </li>
+
   <li class="nav-section">
     <div class="nav-section-header empty"><a href="<?cs
 var:toroot?>about/dashboards/index.html">Dashboards</a></div>
diff --git a/docs/html/about/android.jd b/docs/html/about/android.jd
new file mode 100644
index 0000000..ad0ea7c
--- /dev/null
+++ b/docs/html/about/android.jd
@@ -0,0 +1,111 @@
+page.title=Android, the world's most popular mobile platform
+excludeFromSuggestions=true
+walkthru=0
+header.hide=0
+
+@jd:body
+
+
+<p>Android powers hundreds of millions of mobile devices in more than 190
+countries around the world. It's the largest installed base of any mobile platform
+and growing fast&mdash;every day another million users power up their
+Android devices for the first time and start looking for apps, games,
+and other digital content. </p>
+
+
+<p>Android gives you a world-class platform for creating apps and games for
+Android users everywhere, as well as an open marketplace for distributing
+to them instantly.</p>
+
+<h3>Global partnerships and large installed base</h3>
+
+<p>Building on the contributions of the open-source Linux community and more
+than 300 hardware, software, and carrier partners, Android has rapidly become
+the fastest-growing mobile OS.</p>
+
+<blockquote>Every day more than a million new Android devices are activated worldwide.</blockquote>
+
+<p>Android’s openness has made it a favorite for consumers and developers alike,
+driving strong growth in app consumption. Android users download more than 
+billions of apps and games from Google Play each month. </p>
+
+<p>With its partners, Android is continuously pushing the boundaries of hardware and software
+forward to bring new capabilities to users and developers. For developers, 
+Android innovation lets you build powerful, differentiated applications
+that use the latest mobile technologies.</p>
+
+<h3>Rapid innovation</h3>
+
+<p>Android is continuously pushing the boundaries of hardware and software
+forward, to bring new capabilities to users and developers. For developers, the
+rapid evolution of Android technology lets you stay in front with powerful,
+differentiated applications.</p>
+
+<p>Android gives you access to the latest technologies and innovations across a
+multitude of device form-factors, chipset architectures, and price points. From
+multicore processing and high-performance graphics to state-of-the-art sensors,
+vibrant touchscreens, and emerging mobile technologies.</p>
+
+<h3>Powerful development framework</h3>
+
+<blockquote>Easily optimize a single binary for phones, tablets, and other devices.</blockquote>
+
+<p>Android gives you everything you need to build best-in-class app experiences.
+It gives you a single application model that lets you deploy
+your apps broadly to hundreds of millions of users across a wide range of
+devices&mdash;from phones to tablets and beyond.</p>
+
+<p>Android also gives you tools for creating apps that look great and take
+advantage of the hardware capabilities available on each device. It
+automatically adapts your UI to look its best on each device, while giving you
+as much control as you want over your UI on different device
+types. </p> 
+
+<p>For example, you can create a single app binary that's optimized for
+both phone and tablet form factors. You declare your UI in lightweight sets of XML
+resources, one set for parts of the UI that are common to all form factors and
+other sets for optimzations specific to phones or tablets.
+At runtime, Android applies the correct resource sets based on its screen size,
+density, locale,
+and so on.</p>
+
+
+<p>To help you develop efficiently, the <a href="{@docRoot}tools/index.html">Android 
+    Developer Tools</a>
+offer a full Java IDE with advanced features for developing, debugging, and
+packaging Android apps. Using the IDE, you can develop on any available Android
+device or create virtual devices that emulate any hardware configuration.</p>
+
+<blockquote>1.5 billion downloads a month and growing. Get your apps in front
+of millions of users at Google's scale.</blockquote>
+
+<h3>Open marketplace for distributing your apps</h3>
+
+<p>Google Play is the premier marketplace for selling and distributing Android apps.
+When you publish an app on Google Play, you reach the huge installed base of
+Android.</p>
+
+<div style="float:left;margin-right:24px;margin-top:12px;">
+<img src="{@docRoot}images/gp-device.png">
+</div>
+
+<p>As an open marketplace, Google Play puts you in control of how you sell your
+products. You can publish whenever you want, as often as you want, and to the
+customers you want. You can distribute broadly to all markets and
+devices or focus on specific segments, devices, or ranges of hardware
+capabilities.</p>
+
+<p>You can monetize in the way that works best for your business&mdash;priced or
+free, with in-app products or subscriptions&mdash;for highest engagement and
+revenues. You also have complete control of the pricing for your apps
+and in-app products and can set or change prices in any supported currency at
+any time.<p>
+
+<p>Beyond growing your customer base, Google Play helps you build visibility and
+engagement across your apps and brand. As your apps rise in popularity, Google
+Play gives them higher placement in weekly "top" charts and rankings, and for
+the best apps promotional slots in curated collections.
+</p>
+
+<p>Preinstalled on hundreds of billions of Android devices around the world,
+Google Play can be a growth engine for your business.</p>
\ No newline at end of file
diff --git a/docs/html/about/versions/lollipop.jd b/docs/html/about/versions/lollipop.jd
index 8bc7200..63a6fe9 100644
--- a/docs/html/about/versions/lollipop.jd
+++ b/docs/html/about/versions/lollipop.jd
@@ -3,47 +3,10 @@
 @jd:body
 
 
-
-
-
-
-
-
-
-
-  <div style="padding:0px 0px 0px 20px;float:right;margin:0 -10px 0 0">
-    <img src="{@docRoot}images/home/l-hero_2x.png" srcset="{@docRoot}images/home/l-hero.png 1x, {@docRoot}images/home/l-hero_2x.png 2x" width="460" height="300" >
-  </div>
-
-  <div class="landing-docs" style="float:right;clear:both;margin:68px 0 2em 3em;">
-  <div class="col-4 normal-links highlights" style="font-size:12px;">
-    <h3 id="thisd" >Key Developer Features</h3>
-    <ul style="list-style-type:none;">
-  <li><a href="#Material">Material design</a></li>
-  <li><a href="#Perf">Performance focus</a></li>
-  <li><a href="#Notifications">Notifications</a></li>
-  <li><a href="#TV">Your apps on the big screen</a></li>
-  <li><a href="#Documents">Document-centric apps</a></li>
-  <li><a href="#Connectivity">Advanced connectivity</a></li>
-  <li><a href="#Graphics">High-performance graphics</a></li>
-  <li><a href="#Audio">More powerful audio</a></li>
-  <li><a href="#Camera">Enhanced camera & video</a></li>
-  <li><a href="#Work">Android in the workplace</a></li>
-  <li><a href="#ScreenCapture">Screen capturing and sharing</a></li>
-  <li><a href="#Sensors">New types of sensors</a></li>
-  <li><a href="#WebView">Chromium WebView</a></li>
-  <li><a href="#Accessibility">Accessibility & input</a></li>
-  <li><a href="#Battery">Tools for battery-efficient apps</a></li>
-    </ul>
-  </div>
+<div style="float:right;">
+  <img src="{@docRoot}images/home/l-hero_2x.png" srcset="/images/home/l-hero.png 1x, /images/home/l-hero_2x.png 2x">
 </div>
 
-
-
-
-
-
-
 <p>Welcome to Android 5.0 Lollipop&mdash;the largest and most ambitious release for Android yet!</p>
 
 <p>This release is packed with new features for users and thousands of new APIs for developers. It extends Android even further, from phones, tablets, and wearables, to TVs and cars.</p>
@@ -55,47 +18,63 @@
 <a href="http://www.android.com/versions/lollipop-5-0/"
 >www.android.com</a>.</p>
 
+<div id="qv-wrapper">
+<div id="qv">
+  <h2>Key developer features</h2>
+  <ol>
+      <ul style="list-style-type:none;">
+        <li><a href="#Material">Material design</a></li>
+        <li><a href="#Perf">Performance focus</a></li>
+        <li><a href="#Notifications">Notifications</a></li>
+        <li><a href="#TV">Your apps on the big screen</a></li>
+        <li><a href="#Documents">Document-centric apps</a></li>
+        <li><a href="#Connectivity">Advanced connectivity</a></li>
+        <li><a href="#Graphics">High-performance graphics</a></li>
+        <li><a href="#Audio">More powerful audio</a></li>
+        <li><a href="#Camera">Enhanced camera & video</a></li>
+        <li><a href="#Work">Android in the workplace</a></li>
+        <li><a href="#ScreenCapture">Screen capturing and sharing</a></li>
+        <li><a href="#Sensors">New types of sensors</a></li>
+        <li><a href="#WebView">Chromium WebView</a></li>
+        <li><a href="#Accessibility">Accessibility & input</a></li>
+        <li><a href="#Battery">Tools for battery-efficient apps</a></li>
+      </ol>
+</div>
+</div>
+
 <p class="note">
   <strong>Note:</strong> The Android 5.1 Lollipop MR1 update is available with additional features
   and fixes. For more information, see the
   <a href="{@docRoot}about/versions/android-5.1.html">Android 5.1 API Overview</a>.
 </p>
 
-
 <h2 id="Material">Material design</h2>
 
 <p>Android 5.0 brings <a href="http://www.google.com/design/spec">Material design</a> to Android and gives you an expanded UI toolkit for integrating the new design patterns easily in your apps.  </p>
 
-
-
 <p>New <strong>3D views</strong> let you set a z-level to raise elements off of the view hierarchy and cast <strong>realtime shadows</strong>, even as they move.</p>
 
-
 <p>Built-in <strong>activity transitions</strong> take the user seamlessly from one state to another with beautiful, animated motion. The material theme adds transitions for your activities, including the ability to use <strong>shared visual elements</strong> across activities.</p>
 
-
-
-<div style="width:290px;margin-right:35px;float:left">
+<div style="float:left;max-width:280px;margin-right:1em;">
   <div class="framed-nexus5-port-span-5">
   <video class="play-on-hover" autoplay="">
-    <source src="/design/material/videos/ContactsAnim.mp4">
-    <source src="/design/videos/ContactsAnim.webm">
-    <source src="/design/videos/ContactsAnim.ogv">
+    <source src="{@docRoot}design/material/videos/ContactsAnim.mp4">
+    <source src="{@docRoot}design/videos/ContactsAnim.webm">
+    <source src="{@docRoot}design/videos/ContactsAnim.ogv">
   </video>
-  </div>
-  <div style="font-size:10pt;margin-left:20px;margin-bottom:30px">
+</div>
+  <p style="img-caption">
     <em>To replay the movie, click on the device screen</em>
-  </div>
+  </p>
 </div>
 
-
-<p>Ripple animations are available for buttons, checkboxes, and other touch controls in your app.
+<p>Ripple animations are available for buttons, checkboxes, and other touch controls in your app.</p>
 
 <p>You can also define vector drawables in XML and animate them in a variety of ways. Vector drawables scale without losing definition, so they are perfect for single-color in-app icons.</p>
 
 <p>A new system-managed processing thread called <strong>RenderThread</strong> keeps animations smooth even when there are delays in the main UI thread. </p>
 
-
 <h2 id="Perf">Performance focus</h2>
 
 <p>Android 5.0 provides a faster, smoother and more powerful computing experience.</p>
@@ -112,9 +91,12 @@
 
 <h2 id="Notifications">Notifications</h2>
 
+<div style="float:right;clear:left;margin:1em;">
+<img src="{@docRoot}images/versions/notification-headsup.png" />
+</div>
+
 <p>Notifications in Android 5.0 are more visible, accessible, and configurable. </p>
 
-<img src="{@docRoot}images/versions/notification-headsup.png" style="float:right; margin:0 0 40px 60px" width="300" height="224" />
 
 <p>Varying notification details may appear <strong>on the lock screen</strong> if desired by the user. Users may elect to allow none, some, or all notification content to be shown on a secure lock screen. </p>
 
@@ -124,8 +106,6 @@
 
 <p>A new media notification template provides consistent media controls for notifications with up to 6 action buttons, including custom controls such as "thumbs up"&mdash;no more need for RemoteViews!</p>
 
-
-
 <h2 id="TV">Your apps on the big screen</h2>
 
 <p><a href="http://developer.android.com/tv/index.html">Android TV</a> provides a complete TV platform for your app's big screen experience. Android TV is centered around a simplified home screen experience that allows users to discover content easily, with personalized recommendations and voice search.</p>
@@ -136,12 +116,14 @@
 
 <p>The TV Input Framework provides access to a wide variety of live TV input sources and brings them together in a single user interface for users to browse, view, and enjoy content. Building a TV input service for your content can help make your content more accessible on TV devices.</p>
 
-
-
-<img src="{@docRoot}images/versions/recents_screen_2x.png" srcset="{@docRoot}images/versions/recents_screen.png 1x, {@docRoot}images/versions/recents_screen_2x.png 2x" style="float:right; margin:0 0 40px 60px" width="300" height="521" />
-
 <h2 id="Documents">Document-centric apps</h2>
 
+<div style="float:right;margin:1em;max-width:320px">
+<img src="{@docRoot}images/versions/recents_screen_2x.png"
+    srcset="/images/versions/recents_screen.png 1x, /images/versions/recents_screen_2x.png 2x" />
+<p class="img-caption">Document-centric recents.</p>
+</div>
+
 <p>Android 5.0 introduces a redesigned Overview space (formerly called Recents) that’s more versatile and useful for multitasking.</p>
 
 <p>New APIs allow you to show separate activities in your app as individual documents alongside other recent screens.</p>
@@ -149,7 +131,6 @@
 <p>You can take advantage of concurrent documents to provide users instant access to more of your content or services. For example, you might use concurrent documents to represent files in a productivity app, player matches in a game, or chats in a messaging app. </p>
 
 
-
 <h2 id="Connectivity">Advanced connectivity</h2>
 
 <p>Android 5.0 adds new APIs that allow apps to perform concurrent operations with <strong>Bluetooth Low Energy</strong> (BLE), allowing both scanning (central mode) and advertising (peripheral mode).</p>
@@ -164,14 +145,13 @@
 
 <p>Support for <strong><a href="http://www.khronos.org/opengles/3_X/">Khronos OpenGL ES 3.1</a></strong> now provides games and other apps the highest-performance 2D and 3D graphics capabilities on supported devices. </p>
 
-<p>OpenGL ES 3.1 adds compute shaders, stencil textures, accelerated visual effects, high quality ETC2/EAC texture compression, advanced texture rendering, standardized texture size and render-buffer formats, and more.</p>
-
-
-<div class="figure" style="width:350px; margin:0 0 0 60px">
-<img src="{@docRoot}images/versions/rivalknights.png" style="float:right;" width="350" height="525" />
+<div style="float:right;margin:1em;max-width:350px">
+<img src="{@docRoot}images/versions/rivalknights.png"  />
 <p class="img-caption">Gameloft's Rival Knights uses ASTC (Adaptive Scalable Texture Compression) from AEP and Compute Shaders from ES 3.1 to deliver HDR (High Dynamic Range) Bloom effects and provide more graphical detail.</p>
 </div>
 
+<p>OpenGL ES 3.1 adds compute shaders, stencil textures, accelerated visual effects, high quality ETC2/EAC texture compression, advanced texture rendering, standardized texture size and render-buffer formats, and more.</p>
+
 <p>Android 5.0 also introduces the <strong>Android Extension Pack</strong> (AEP), a set of OpenGL ES extensions that give you access to features like tessellation shaders, geometry shaders, ASTC texture compression, per-sample interpolation and shading, and other advanced rendering capabilities. With AEP you can deliver high-performance graphics across a range of GPUs.</p>
 
 
@@ -187,7 +167,7 @@
 
 <p>Android now includes support for standard <strong>USB audio</strong> peripherals, allowing users to connect USB headsets, speakers, microphones, or other high performance digital peripherals. Android 5.0 also adds support for <strong>Opus</strong> audio codecs.</p>
 
-<p>New <strong>{@link android.media.session.MediaSession}</strong> APIs for controlling media playback now make it easier to provide consistent media controls across screens and other controllers.</p>
+<p>New <strong><code><a href="{@docRoot}reference/android/media/session/MediaSession.html">MediaSession</a></code></strong> APIs for controlling media playback now make it easier to provide consistent media controls across screens and other controllers.</p>
 
 
 <h2 id="Camera">Enhanced camera &amp; video</h2>
@@ -203,19 +183,17 @@
 <p>Android 5.0 also adds support for <strong>multimedia tunneling</strong> to provide the best experience for ultra-high definition (4K) content and the ability to play compressed audio and video data together. </p>
 
 
+<h2 id="Work">Android in the workplace</h2>
 
-<div class="figure" style="width:320px; margin:1em 0 0 20px;padding-left:2em;">
-<img style="float:right; margin:0 1em 1em 2em"
+<div style="float:right;margin:1em;max-width:330px">
+<img 
     src="{@docRoot}images/android-5.0/managed_apps_launcher@2x.png"
-    srcset="{@docRoot}images/android-5.0/managed_apps_launcher@2x.png 2x"
-    alt="" width="300" />
+    srcset="/images/android-5.0/managed_apps_launcher@2x.png 2x"
+    alt="" />
 <p class="img-caption">Users have a unified view of their personal and work apps, which are
 badged for easy identification.</p>
 </div>
 
-
-<h2 id="Work">Android in the workplace</h2>
-
 <p>To enable bring-your-own-device for enterprise environments, a new
 <a href="{@docRoot}about/versions/android-5.0.html#Enterprise">managed provisioning process</a>
 creates a secure work profile on the device. In the launcher, apps are shown with a Work badge to
@@ -231,8 +209,6 @@
 issue these devices with a device owner app already installed that
 can configure global device settings.</p>
 
-
-
 <h2 id="ScreenCapture">Screen capturing and sharing</h2>
 
 <p>Android 5.0 lets you add screen capturing and screen sharing capabilities to your app. </p>
@@ -247,14 +223,13 @@
 <p>New <strong>interaction composite sensors</strong> are now available to detect special interactions such as a <em>wake up</em> gesture, a <em>pick up</em> gesture, and a <em>glance</em> gesture.</p>
 
 
-
 <h2 id="WebView">Chromium WebView</h2>
 
 <div style="float:right;margin:1em 2em 1em 2em;">
-  <img src="/images/kk-chromium-icon.png" alt="" height="160" style="margin-bottom:0em;">
+  <img src="{@docRoot}images/kk-chromium-icon.png" alt="" height="160" style="margin-bottom:0em;">
 </div>
 
-<p>The initial release for Android 5.0 includes a version of Chromium for {@link android.webkit.WebView} based on the Chromium M37 release, adding support for <strong>WebRTC</strong>, <strong>WebAudio</strong>, and <strong>WebGL</strong>. </p>
+<p>The initial release for Android 5.0 includes a version of Chromium for <code><a href="{@docRoot}reference/android/webkit/WebView.html">WebView</a></code> based on the Chromium M37 release, adding support for <strong>WebRTC</strong>, <strong>WebAudio</strong>, and <strong>WebGL</strong>. </p>
 
 <p>Chromium M37 also includes native support for all of the <strong>Web Components</strong> specifications: Custom Elements, Shadow DOM, HTML Imports, and Templates. This means you can use <a href="http://polymer-project.org/">Polymer</a> and its <a href="https://www.polymer-project.org/docs/elements/material.html">material design elements</a> in a WebView without needing polyfills.</p>
 
@@ -262,8 +237,6 @@
 
 <p>As new versions of Chromium become available, users can update from Google Play to ensure they get the latest enhancements and bug fixes for WebView, providing the latest web APIs and bug fixes for apps using WebView on Android 5.0 and higher.</p>
 
-
-
 <h2 id="Accessibility">Accessibility &amp; input</h2>
 
 <p>New accessibility APIs can retrieve detailed information about the properties of windows on the screen that sighted users can interact with and define standard or customized input actions for UI elements.</p>
@@ -271,13 +244,12 @@
 <p>New Input method editor (IME) APIs enable faster switching to other IMEs directly from the input method.</p>
 
 
-
 <h2 id="Battery">Tools for building battery-efficient apps</h2>
 
 <p>New <strong>job scheduling</strong> APIs allow you optimize battery life by deferring jobs for the system to run at a later time or under specified conditions, such as when the device is charging or connected to Wi-Fi.</p>
 
 <p>A new <code>dumpsys batterystats</code> command generates <strong>battery usage statistics</strong> that you can use to understand system-wide power use and understand the impact of your app on the device battery. You can look at a history of power events, approximate power use per UID and system component, and more.</p>
 
-<img src="{@docRoot}images/versions/battery_historian.png" srcset="{@docRoot}images/versions/battery_historian@2x.png 2x" alt="" width="760" height="462" />
+<img src="{@docRoot}images/versions/battery_historian.png" srcset="/images/versions/battery_historian@2x.png 2x" alt="" width="760" height="462" />
 <p class="img-caption">Battery Historian is a new tool to convert the statistics from <code>dumpsys batterystats</code> into a visualization for battery-related debugging. You can find it at <a href="https://github.com/google/battery-historian"
->https://github.com/google/battery-historian</a>.</p>
+>https://github.com/google/battery-historian</a>.</p>
\ No newline at end of file
diff --git a/docs/html/develop/index.jd b/docs/html/develop/index.jd
index d66f8f4..12793eb 100644
--- a/docs/html/develop/index.jd
+++ b/docs/html/develop/index.jd
@@ -60,7 +60,7 @@
        data-maxResults="3"></div>
 </div></section>
 
-<section class="dac-section dac-section-light"><div class="wrap">
+<section class="dac-section dac-light"><div class="wrap">
   <h1 class="dac-section-title">Tools for building apps</h1>
   <div class="dac-section-subtitle">
     Insights into Android's tools and libraries to speed your development.
@@ -74,7 +74,7 @@
   </ul>
 </div></section>
 
-<section class="dac-section dac-light"><div class="wrap">
+<section class="dac-section dac-section-light"><div class="wrap">
   <h1 class="dac-section-title">Android performance patterns</h1>
   <div class="dac-section-subtitle">
     Everything you need to know about improving your app’s performance.
diff --git a/docs/html/distribute/analyze/index.jd b/docs/html/distribute/analyze/index.jd
index f948dbd..c40a699 100644
--- a/docs/html/distribute/analyze/index.jd
+++ b/docs/html/distribute/analyze/index.jd
@@ -31,8 +31,6 @@
   data in AdMob</a> and have the full picture of your app revenue.
 </p>
 
-<div class="dynamic-grid">
-
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/analyzelanding"
     data-cardSizes="6x6"
diff --git a/docs/html/distribute/analyze/start.jd b/docs/html/distribute/analyze/start.jd
index 2a5a9f4..c3a1f87 100644
--- a/docs/html/distribute/analyze/start.jd
+++ b/docs/html/distribute/analyze/start.jd
@@ -1,7 +1,7 @@
 page.title=Get Started with Analytics
 page.metaDescription=Unlock the power of Analytics by choosing the implementation that works best for your app.
 page.tags="analytics, user behavior"
-page.image=distribute/images/gp-analytics-logo.jpg
+page.image=images/cards/card-analytics_2x.png
 
 
 @jd:body
diff --git a/docs/html/distribute/engage/ads.jd b/docs/html/distribute/engage/ads.jd
index 9ca72f3..ad6940f 100644
--- a/docs/html/distribute/engage/ads.jd
+++ b/docs/html/distribute/engage/ads.jd
@@ -15,21 +15,26 @@
   app engagement campaigns</a>.
 </p>
 
-<div>
- <div class="figure-left" style="width:46%;">
+
+
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-1of2">
    <h3>From search</h3>
    <img src="/images/distribute/promote_ads.png">
     <p class="figure-caption">Add deep links to your app, then bring users straight
     to relevant app content when they’re searching.</p>
-  </div>
-  <div class="figure-right" style="width:46%;">
+    </div>
+    <div class="col-1of2">
     <h3>From apps</h3>
     <img src="/images/distribute/promote_ads_inapp.png">
     <p class="figure-caption">Use remarketing and deep links to bring users to just the right
     place in your app to re-engage and convert, from other apps and games they love.</p>
+    </div>
   </div>
 </div>
 
+
 <h3 id="tips">Tips</h2>
 
 <ul>
diff --git a/docs/html/distribute/engage/appindexing.jd b/docs/html/distribute/engage/appindexing.jd
deleted file mode 100644
index 2b8f315..0000000
--- a/docs/html/distribute/engage/appindexing.jd
+++ /dev/null
@@ -1,61 +0,0 @@
-page.title=Bring Users from Google Search
-page.metaDescription=Use search to bring your existing users back into your app.
-page.image=images/cards/adwords_2x.jpg
-page.tags="engagement, search"
-@jd:body
-
-<p>Use the features of Google Search for Android to drive the use of your apps: </p>
-
-<ul>
-<li>Once users have installed your app, search can bring them back with <strong>deep-links</strong> direct to your app. </li>
-  <li>When users use <strong>voice commands</strong> to ask Google to perform a task, your app can be one of those
-completing the task.</li>
-
-<li>You can also take advantage of <strong>Google Now</strong> to
-display cards for event, flight, hotel, and restaurant reservations you notify
-to users’ gmail addresses, and bring users back from the email linked to the
-card.</li>
-</ul>
-
-<p>Start now by <a href="https://developers.google.com/app-indexing/">indexing your app</a>, then take advantage of <a href="https://developers.google.com/voice-actions/">Voice Actions</a>, the <a href="https://developers.google.com/app-indexing/webmasters/appindexingapi">App Indexing API</a>, and <a href="https://developers.google.com/schemas/now/cards">Google Now Cards</a>.</p>
-
-
-<h2 id="help_users_find_your_information">Help Users Find Your Information</h2>
-
-<p>Re-engage with your users with deep-links displayed in search results, links
-that take users directly to content within your app.</p>
-
-
-<div style="margin-top:1.5em;margin-left:24px">
-<img src="{@docRoot}images/distribute/more-app-engagement.png">
-</div>
-<h2 id="empower_users_in_your_app">Empower your users to get things done in your app</h2>
-
-<p>Brings your users into your app to take action with voice actions such as “Ok
-Google, play a song” with the music app of choice, or “Ok Google, search for
-hotels in Maui on TripAdvisor” in the TripAdvisor app.</p>
-
-<div style="margin-top:1em">
-<img src="{@docRoot}images/distribute/music-action.png">
-</div>
-
-
-<h2 id="assist_your_users">Assist your users where and when they need it</h2>
-
-<div class="figure">
-<img src="https://developers.google.com/schemas/images/now_eventconfirmation.png">
-</div>
-
-<p>Inform your users of their reservations with cards created from structured data
-markup delivered in Gmail notifications. Cards also lead users quickly back to
-your email message, for further engagement.</p>
-
-<h2 style="clear:both" id="related-resources">Related Resources</h2>
-
-<div class="resource-widget resource-flow-layout col-13"
-  data-query="collection:distribute/engage/appindexing"
-  data-sortOrder="-timestamp"
-  data-cardSizes="9x3"
-  data-maxResults="6"></div>
-
-
diff --git a/docs/html/distribute/engage/deep-linking.jd b/docs/html/distribute/engage/deep-linking.jd
index 0c78a50..701cb99 100644
--- a/docs/html/distribute/engage/deep-linking.jd
+++ b/docs/html/distribute/engage/deep-linking.jd
@@ -1,4 +1,4 @@
-page.title=Drive Usage with Search
+page.title=Increase Usage with Search
 page.metaDescription=Use search to bring your existing users back into your app.
 page.image=images/cards/google-search_2x.png
 page.tags=engagement, appindexing, search
@@ -47,13 +47,12 @@
 
 <h2 id="assist_your_users">Google Now</h2>
 
-<div style="margin-top:1em">
-<img src="{@docRoot}images/distribute/google-now-engagement.png">
-</div>
-
 <p>If you’re building travel, entertainment, or restaurant apps, Google Now cards
 can re-engage your users via structured data markup delivered in email notifications.</p>
 
+<div style="margin-top:1em">
+<img src="{@docRoot}images/distribute/google-now-engagement.png">
+</div>
 
 <h2 id="tips">Tips</h2>
 
@@ -70,7 +69,7 @@
 <div class="resource-widget resource-flow-layout col-13"
   data-query="collection:distribute/engage/appindexing"
   data-sortOrder="-timestamp"
-  data-cardSizes="9x3"
-  data-maxResults="6"></div>
+  data-cardSizes="6x2"
+  data-maxResults="3"></div>
 
 
diff --git a/docs/html/distribute/engage/easy-signin.jd b/docs/html/distribute/engage/easy-signin.jd
index 2bfa5d1..924c5b4 100644
--- a/docs/html/distribute/engage/easy-signin.jd
+++ b/docs/html/distribute/engage/easy-signin.jd
@@ -1,105 +1,76 @@
-page.title=Make Signing In Easy
+page.title=Add Quick and Secure Google Sign-in
 page.metaDescription=Increase conversion rates while helping users minimize typing by letting users sign in with Google+.
-page.tags="google+"
+page.tags="google", "identity", "signin"
 page.image=images/cards/google-sign-in_2x.png
 
-
 @jd:body
 
-<div class="sidebox-wrapper" style="float:right;">
-  <div class="sidebox" style="width:360px;">
-    <p>
-      <strong>Tip:</strong> For game developers, Google+ signin is already
-      included as part of Google Play game services.
-    </p>
+<p>Get people into your apps quickly and securely, using a registration system they
+already use and trust – their Google account. With minimal effort, you can increase
+registration and sign-in conversion by adding trusted registration system that's
+familiar to users, consistent across devices, and quick and easy to use.</p>
+
+<p>Get started <a href="https://developers.google.com/identity/sign-in/">integrating
+Google sign-in into your apps and games</a>.</p>
+
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-3of12">
+      <h3>Quick and secure app access</h3>
+        <p>A secure authentication system that makes sign-in easy for your users by
+        letting them use their Google account, which they already use with Gmail,
+        Play, Google+, and other Google services.</p>
+    </div>
+    <div class="col-8of12 col-push-1of12">
+     <img src="{@docRoot}images/distribute/signin-secure.png" style="padding-top:1em;">
+    </div>
+  </div>
+
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-3of12">
+      <h3>Seamless experience across screens</h3>
+      <p>Keep your users engaged, no matter what device they pick up or sit down at.
+      Offer a seamless app experience across devices and into your website, securely
+      from a one-time consent. </p>
+    </div>
+    <div class="col-8of12  col-push-1of12">
+      <img src="{@docRoot}images/distribute/signin-seamless.png" style="padding-top:1em;">
+    </div>
+  </div>
+
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-3of12">
+      <h3>Help your users take action with Google</h3>
+        <p>Securely connect users with Google services and let them pay with Google
+        Wallet, share with Google contacts, save files to Drive, add events to
+        Calendar, and more.</p>
+    </div>
+    <div class="col-8of12 col-push-1of12">
+     <img src="{@docRoot}images/distribute/signin-apps.png" style="padding-top:1em;">
+    </div>
   </div>
 </div>
 
-<p>
-  Increase conversion rates while helping users minimize typing by letting
-  users sign in with Google+. The <a href=
-  "{@docRoot}google/play-services/plus.html">Google+ platform for Android</a>
-  authenticates users with their Google credentials safely and securely. With
-  your <a href="https://developers.google.com/+/mobile/android/sign-in">users
-  signing in with Google</a>, you can create more engaging experiences and
-  drive the use of your apps .
-</p>
 
-<div style="width:450px;">
-  <img src="{@docRoot}images/google/gps-googleplus.png" style="padding-top:1em;">
-</div>
-
-<p>
-  Use the Google+ social graph to welcome users by name, display their
-  pictures, connect them with friends and more. Users authenticate once and
-  then are signed-in automatically when they come back, eliminating the need to
-  remember and type names and passwords.
-</p>
-
-<div class="headerLine">
-  <h2>
-    And Spreading the Word a Snap
-  </h2>
-
-
-</div>
-
-
-<div class="figure" style="float:right;">
-  <img src="{@docRoot}images/gp-engage-share-plus.png" style=
-  "width:160px;padding-top:1em;">
-  <p class="img-caption">
-    Easy sharing through Google+
-  </p>
-</div>
-
-
-<p>
-  Using Google+ can help users spread the word about your apps to their
-  friends, attracting them to your apps, right from within your apps:
-</p>
-
-<p>
-  Google+ is also a great way to build a community of loyal fans that will help
-  you with <a href=
-  "https://support.google.com/googleplay/android-developer/answer/3131213">beta
-  testing</a>.
-</p>
+<h2>Tips</h2>
 
 <ul>
-  <li>Using a <a href=
-  "https://developers.google.com/+/mobile/android/recommend">native +1
-  button</a> to let users make a recommendation for your apps or their content.
-  </li>
-
-  <li>
-    <a href="https://developers.google.com/+/mobile/android/share/">Share rich
-    content</a> to the Google+ stream, including text, photos, URL attachments,
-    and location.
-  </li>
-
-  <li>Create <a href=
-  "https://developers.google.com/+/mobile/android/share/interactive-post">Interactive
-  posts</a> to share your website or apps, users can even invite friends to
-  "listen," "RSVP," "check-in," or one of over 100 actions.
-  </li>
+<li>Add <strong>over-the-air installs</strong> to your website. After signing in with Google
+  on the web, users will have the option to send your Android app to their device instantly,
+  without them ever leaving your website.</li>
+  <li>With Google sign-in, you can take advantage of other <strong>Google+ platform
+  features</strong> like adding a +1 button so users can make recommendations and the ability
+  to share rich content to the Google+ stream.</li>
 </ul>
 
-<p style="clear:both">
-</p>
-  <div class="headerLine">
-    <h2 id="related-resources">
-      Related Resources
-    </h2>
 
+<h2 style="clear:both" id="related-resources">Related Resources</h2>
 
-  </div>
-
-  <div class="resource-widget resource-flow-layout col-13"
+<div class="resource-widget resource-flow-layout col-13"
   data-query="collection:distribute/engage/gplus"
   data-sortorder="-timestamp"
   data-cardsizes="9x3"
-  data-maxresults="6">
-  </div>
+  data-maxresults="4">
 </div>
 
+
diff --git a/docs/html/distribute/engage/engage_toc.cs b/docs/html/distribute/engage/engage_toc.cs
index 7094713..f8607f5 100644
--- a/docs/html/distribute/engage/engage_toc.cs
+++ b/docs/html/distribute/engage/engage_toc.cs
@@ -20,7 +20,7 @@
   <li class="nav-section">
     <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs
         var:toroot?>distribute/engage/easy-signin.html">
-        <span class="en">Make Signing In Easy</span></a>
+        <span class="en">Add Google Sign-in</span></a>
     </div>
   </li>
   <li class="nav-section">
@@ -41,7 +41,6 @@
         <span class="en">Use the Power of Intents</span></a>
     </div>
   </li>
-
   <li class="nav-section">
     <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs
         var:toroot?>distribute/engage/analytics.html">
diff --git a/docs/html/distribute/engage/index.jd b/docs/html/distribute/engage/index.jd
index a47e004..165cc0e 100644
--- a/docs/html/distribute/engage/index.jd
+++ b/docs/html/distribute/engage/index.jd
@@ -11,8 +11,6 @@
   techniques to keep your users coming back.
 </p>
 
-<div class="dynamic-grid">
-
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/engagelanding"
     data-cardSizes="6x6"
@@ -20,22 +18,14 @@
   </div>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/engagelanding"
-    data-cardSizes="6x2"
+    data-cardSizes="6x3"
     data-maxResults="20">
   </div>
 
-  <h3>Related Resources</h3>
+<!--  <h2>Related Resources</h2>
   <div class="resource-widget resource-flow-layout col-16"
-    data-query="type:youtube+tag:engagement"
-    data-sortOrder="-timestamp"
-    data-cardSizes="6x3"
+    data-query="tag:engagement"
+    data-sortOrder="random"
+    data-cardSizes="6x2"
     data-maxResults="3">
-  </div>
-  <div class="resource-widget resource-flow-layout col-16"
-    data-query="type:blog+tag:engagement"
-    data-sortdOrder="-timestamp"
-    data-cardSizes="6x3"
-    data-maxResults="3">
-  </div>
-
-</div>
\ No newline at end of file
+  </div> -->
diff --git a/docs/html/distribute/essentials/best-practices/apps.jd b/docs/html/distribute/essentials/best-practices/apps.jd
deleted file mode 100644
index bbac727..0000000
--- a/docs/html/distribute/essentials/best-practices/apps.jd
+++ /dev/null
@@ -1,260 +0,0 @@
-page.title=App Developer Best Practices
-page.image=/distribute/images/gp-app-practices.png
-page.metaDescription=Essential tips for launching successful apps in Google Play.
-@jd:body
-
-<div id="qv-wrapper"><div id="qv">
-<h2>Best Practices</h2>
-<ol>
-<li><a href="#essentials">Get the Essentials Right</a></li>
-<li><a href="#users">Get Users</a></li>
-<li><a href="#engage">Engage and Retain</a></li>
-<li><a href="#beyond">Beyond the Basics</a></li>
-<li><a href="#related-resources">Related Resources</a></li>
-</ol>
-</div></div>
-
-<p>The following best practices have enabled developers worldwide to build great, successful apps for Google Play.</p>
-
-<div class="headerLine">
-<h2 id="essentials">Get the Essentials Right</h2>
-</div>
-
-<h3>1. Make it Android</h3>
-
-<ul>
-  <li>
-  <p>
-    Build your apps to make best use of the unique Android features, such as
-    <a href="{@docRoot}distribute/engage/widgets.html">widgets</a>, <a href=
-    "{@docRoot}distribute/engage/notifications.html">rich notifications</a>,
-    <a href=
-    "http://android-developers.blogspot.com/2012/02/share-with-intents.html">sharing
-    through Intents</a>, and more.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Add the power of Google features your users already love, such as
-    <a href="https://developers.google.com/maps/documentation/android/">Google
-    Maps</a>, <a href="https://developers.google.com/drive/">Google
-    Drive</a>, and more, all with <a href=
-    "https://developers.google.com/+/mobile/android/sign-in">single sign
-    on</a>.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  2. Make it quality
-</h3>
-
-<ul>
-  <li>
-  <p>
-    Make sure your apps follow the <a href=
-    "{@docRoot}distribute/essentials/quality/core.html">Core App Quality</a>
-    guidelines.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Create apps that are available on all form factors and screen sizes, by
-    following the <a href=
-    "{@docRoot}distribute/essentials/quality/tablets.html">Tablet App
-    Quality</a> guidelines.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Test and <a href=
-    "{@docRoot}distribute/essentials/optimizing-your-app.html">optimize your
-    quality</a> at every step and make use of the Google Play <a href=
-    "{@docRoot}distribute/googleplay/developer-console.html#alpha-beta">beta-testing</a>
-    and <a href=
-    "{@docRoot}distribute/googleplay/developer-console.html#staged-rollouts">staged
-    rollouts</a> features to test with users before launch.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-  <h2 id="users">
-  Get Users
-  </h2>
-
-
-</div>
-
-<h3>
-  1. Build buzz
-</h3>
-
-<ul>
-  <li>
-  <p>
-    Create a great <a href="{@docRoot}distribute/users/your-listing.html">app
-    listing page</a> to showcase your apps and grab users’ attention. Don’t
-    forget to include a <a href=
-    "{@docRoot}distribute/engage/video.html">YouTube video</a>.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href="{@docRoot}distribute/tools/launch-checklist.html">Launch</a> on
-    multiple platforms simultaneously to maximize your reach.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Promote your apps with the official <a href=
-    "{@docRoot}distribute/tools/promote/badges.html">Google Play badge</a>
-    and <a href="{@docRoot}distribute/tools/promote/linking.html">link to
-    your products</a> on Google Play.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Build a community with social media, <a href=
-    "http://groups.google.com/">forums</a>, and <a href=
-    "http://plus.google.com">communities</a> to get and keep users talking.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  2. Optimize for great ratings
-</h3>
-
-<ul>
-  <li>
-  <p>
-    Get to <a href="{@docRoot}distribute/users/know-your-user.html">know your
-    users</a>, listen to and <a href=
-    "{@docRoot}distribute/engage/app-updates.html">update your apps</a> from
-    their feedback.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Focus on your strength markets first, get these right before expanding.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-  <h2 id="engage">
-  Engage and Retain
-  </h2>
-
-
-</div>
-
-<h3>
-  1. Keep users coming back
-</h3>
-
-<ul>
-  <li>
-  <p>
-    Use <a href="{@docRoot}google/play/billing/index.html">Google Play In-app
-    Billing</a> to offer subscriptions to extended features.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Hold competitions and offer promotions, then announce them through
-    <a href="{@docRoot}design/patterns/notifications.html">notifications</a>.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  2. Earn users’ love
-</h3>
-
-<ul>
-  <li>
-  <p>
-    <a href=
-    "http://android-developers.blogspot.com/2013/05/all-google-play-developers-can-now.html">
-    Respond to reviews</a> and get valuable feedback from the community
-    you've built.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href=
-    "http://android-developers.blogspot.com/2013/10/improved-app-insight-by-linking-google.html">
-    Measure</a> your campaigns to see what is driving users to install your
-    apps.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href=
-    "{@docRoot}distribute/essentials/optimizing-your-app.html#measuring-analyzing-responding">
-    Analyze in-app use</a> to steer content updates and prolong the life of
-    your apps.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-  <h2 id="beyond">
-  Beyond the Basics
-  </h2>
-
-
-</div>
-
-<ul>
-  <li>
-  <p>
-    After you’ve launched in your market of strength, <a href=
-    "{@docRoot}distribute/users/expand-to-new-markets.html">expand into other
-    markets</a> strategically and <a href=
-    "{@docRoot}distribute/tools/localization-checklist.html">localize</a>
-    your apps as you go.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Keep users engaged, and stay ahead of the competition, by continually
-    <a href=
-    "{@docRoot}distribute/essentials/optimizing-your-app.html">optimizing
-    your apps</a> to offer new and better features, or retire those that
-    users aren’t using.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Build educational apps: learn <a href=
-    "{@docRoot}distribute/googleplay/edu/start.html">how to make apps for
-    Google Play for Education</a>.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-<h2 id="related-resources">Related Resources</h2>
-</div>
-
-<div class="resource-widget resource-flow-layout col-13"
-  data-query="collection:distribute/toolsreference/bestpractices/apps"
-  data-sortOrder="-timestamp"
-  data-cardSizes="9x3,9x3"
-  data-maxResults="6"></div>
-
diff --git a/docs/html/distribute/essentials/best-practices/games.jd b/docs/html/distribute/essentials/best-practices/games.jd
deleted file mode 100644
index c4ce66e..0000000
--- a/docs/html/distribute/essentials/best-practices/games.jd
+++ /dev/null
@@ -1,259 +0,0 @@
-page.title=Game Developer Best Practices
-page.image=/distribute/images/gp-games-practices.png
-page.metaDescription=Essential tips for launching successful games in Google Play.
-
-@jd:body
-
-<div id="qv-wrapper"><div id="qv">
-<h2>Best Practices</h2>
-<ol>
-<li><a href="#users">Get Users</a></li>
-<li><a href="#engage">Engage and Retain</a></li>
-<li><a href="#beyond">Beyond the Basics</a></li>
-<li><a href="#related-resources">Related Resources</a></li>
-</ol>
-</div></div>
-
-<p>
-  The following best practices have enabled developers worldwide to build
-  great, successful games for Google Play.
-</p>
-
-<div class="headerLine">
-  <h2 id="users">
-  Get Users
-  </h2>
-
-
-</div>
-
-<h3>
-  1. Optimize for great ratings
-</h3>
-
-<ul>
-  <li>
-  <p>
-    <a href=
-    "{@docRoot}distribute/googleplay/developer-console.html#alpha-beta">Beta
-    test</a> to ensure your games are ready and poised for great ratings.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Optimize graphics, frame rates, and responsiveness with the <a href=
-    "http://android-developers.blogspot.com/2013/09/using-hardware-scaler-for-performance.html">
-    Hardware Scaler</a> and <a href=
-    "{@docRoot}training/graphics/opengl/index.html">OpenGL ES</a>.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Be sure your APK is small, then provide game content through over-the-air
-    downloads.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  2. Build buzz
-</h3>
-
-<ul>
-  <li>
-  <p>
-    Build a community with social media, <a href=
-    "{@docRoot}distribute/users/build-community.html">communities</a> to get
-    and keep users talking.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Promote your games with official <a href=
-    "{@docRoot}distribute/tools/promote/badges.html">Google Play badges</a>
-    and <a href="{@docRoot}distribute/tools/promote/linking.html">links to
-    your products</a> on Google Play.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    If you ship on multiple platforms, doing so at the same time can maximize
-    your marketing impact.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  3. Get Visibility
-</h3>
-
-<ul>
-  <li>
-  <p>
-    First impressions count: <a href=
-    "{@docRoot}distribute/users/your-listing.html">highlight</a> the game's
-    best features in screenshots, videos, and description.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Integrate Google Play Game Services, so your game is displayed in the
-    <a href=
-    "https://play.google.com/store/apps/details?id=com.google.android.play.games">
-    Google Play Games App</a>.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-  <h2 id="engage">
-  Engage and Retain
-  </h2>
-
-
-</div>
-
-<h3>
-  1. Keep users coming back
-</h3>
-
-<ul>
-  <li>
-  <p>
-    <a href=
-    "https://developers.google.com/games/services/common/concepts/achievements">
-    Achievements</a>, <a href=
-    "https://developers.google.com/games/services/common/concepts/leaderboards">
-    leaderboards</a>, <a href=
-    "https://developers.google.com/games/services/common/concepts/realtimeMultiplayer">
-    multiplayer</a>, and <a href=
-    "https://developers.google.com/games/services/common/concepts/cloudsave">cloud
-    save</a> help engage users and bring them back.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Hold tournaments and offer promotions, then announce them through
-    <a href="{@docRoot}design/patterns/notifications.html">notifications</a>.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Sign in users early, then automatically. Before their first sign-in, save
-    progress locally.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  2. Give users a reason to invest their money
-</h3>
-
-<ul>
-  <li>
-  <p>
-    A majority of the top grossing games use in-app purchases. Use them to
-    unlock content and allow players to enhance their game play.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href="{@docRoot}google/play/billing/index.html">Google Play In-app
-    Billing</a> makes purchasing easy with several forms of payment.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Provide content updates regularly to give users limited edition items to
-    win or purchase.
-  </p>
-  </li>
-</ul>
-
-<h3>
-  3. Earn players’ love
-</h3>
-
-<ul>
-  <li>
-  <p>
-    <a href=
-    "http://android-developers.blogspot.com/2013/10/improved-app-insight-by-linking-google.html">
-    Measure</a> your campaigns to see what’s driving quality users to install
-    your games.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href=
-    "{@docRoot}distribute/essentials/optimizing-your-app.html#measuring-analyzing-responding">
-    Analyze in-game use</a> to steer content updates and prolong the life of your
-    games.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    <a href=
-    "http://android-developers.blogspot.com/2013/05/all-google-play-developers-can-now.html">
-    Respond to reviews</a> and get valuable feedback from the community
-    you’ve built.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-  <h2 id="beyond">
-  Beyond the Basics
-  </h2>
-
-
-</div>
-
-<ul>
-  <li>
-  <p>
-    After you've launched in your market of strength, <a href=
-    "{@docRoot}distribute/users/expand-to-new-markets.html">expand into other
-    markets</a> strategically and <a href=
-    "{@docRoot}distribute/tools/localization-checklist.html">localize</a>
-    your apps as you go.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Provide content <a href=
-    "{@docRoot}distribute/engage/app-updates.html">updates on a regular
-    basis</a> to keep users engaged.
-  </p>
-  </li>
-
-  <li>
-  <p>
-    Building educational games? See the <a href=
-    "{@docRoot}distribute/essentials/gpfe-guidelines.html">Education
-    Guidelines</a>.
-  </p>
-  </li>
-</ul>
-
-<div class="headerLine">
-<h2 id="related-resources">Related Resources</h2>
-</div>
-
-<div class="resource-widget resource-flow-layout col-13"
-  data-query="collection:distribute/toolsreference/bestpractices/games"
-  data-sortOrder="-timestamp"
-  data-cardSizes="9x3,9x3"
-  data-maxResults="6"></div>
diff --git a/docs/html/distribute/essentials/essentials_toc.cs b/docs/html/distribute/essentials/essentials_toc.cs
index fe3fc87..baca18f 100644
--- a/docs/html/distribute/essentials/essentials_toc.cs
+++ b/docs/html/distribute/essentials/essentials_toc.cs
@@ -34,18 +34,7 @@
         </a>
     </div>
   </li>
-  <li class="nav-section">
-    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/essentials/best-practices/apps.html">
-          <span class="en">App Best Practices</span>
-        </a>
-    </div>
-  </li>
-  <li class="nav-section">
-    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/essentials/best-practices/games.html">
-          <span class="en">Game Best Practices</span>
-        </a>
-    </div>
-  </li>
+</ul>
 
 
 <script type="text/javascript">
diff --git a/docs/html/distribute/essentials/index.jd b/docs/html/distribute/essentials/index.jd
index ca5442a..d5c3397 100644
--- a/docs/html/distribute/essentials/index.jd
+++ b/docs/html/distribute/essentials/index.jd
@@ -12,23 +12,17 @@
   process of monitoring feedback and making improvement after launch.
 </p>
 
-<div class="dynamic-grid">
 <div class="resource-widget resource-flow-layout landing col-16"
   data-query="collection:distribute/essentials"
   data-cardSizes="6x6"
   data-maxResults="6">
 </div>
 
-<h3>Related resources</h3>
+<!-- <h2>Related resources</h2>
 
 <div class="resource-widget resource-flow-layout col-16"
-  data-query="type:blog+tag:quality"
-  data-cardSizes="6x3"
-  data-maxResults="3">
-</div>
-<div class="resource-widget resource-flow-layout col-16"
-  data-query="type:youtube+tag:appquality"
-  data-cardSizes="6x3"
-  data-maxResults="3">
-</div>
-</div>
\ No newline at end of file
+  data-query="tag:quality"
+  data-cardSizes="6x2"
+  data-maxResults="3"
+  data-sortOrder="random">
+</div> -->
diff --git a/docs/html/distribute/googleplay/cardboard.jd b/docs/html/distribute/googleplay/cardboard.jd
index c187ffd..d5965d1 100644
--- a/docs/html/distribute/googleplay/cardboard.jd
+++ b/docs/html/distribute/googleplay/cardboard.jd
@@ -1,12 +1,11 @@
 page.title=Build VR with Google Cardboard
 page.metaDescription=Build apps and games with VR, for a viewer anyone can buy.
-page.image=images/cards/card-cardboard_2x.jpg
 page.tags=vr, carboard, games
 @jd:body
 
 <p>
   Virtual reality promises to transform the way players view games, taking them from a
-  flat world into the realm of 3D. And it’s not just games, any application that provides
+  flat world into the realm of 3D. In fact, any application that provides
   a way to visually explore has the possibility to offer users more immersive experiences
   with VR &mdash; like a virtual tour of a famous landmark or a way to visualise atoms in a
   chemical compound.
diff --git a/docs/html/distribute/googleplay/cast.jd b/docs/html/distribute/googleplay/cast.jd
index 68c0584..95e469b 100644
--- a/docs/html/distribute/googleplay/cast.jd
+++ b/docs/html/distribute/googleplay/cast.jd
@@ -1,6 +1,5 @@
-page.title=Stream Your Content with Google Cast
-page.metaDescription=Let users stream your video and audio content to TVs and speakers.
-page.image=images/cards/card-cast_2x.jpg
+page.title=Stream with Google Cast
+page.metaDescription=Let users stream your video and audio content to their TVs and speakers.
 page.tags=cast, video, chromecast
 @jd:body
 
diff --git a/docs/html/distribute/googleplay/edu/about.jd b/docs/html/distribute/googleplay/edu/about.jd
index 469b899..36a67b26 100644
--- a/docs/html/distribute/googleplay/edu/about.jd
+++ b/docs/html/distribute/googleplay/edu/about.jd
@@ -33,18 +33,20 @@
       <img src="{@docRoot}images/gpfe-developer.png">
     </div>
 
-    <h3>
-      FOR DEVELOPERS
-    </h3>
-    <b>Get discovered</b>
-    <p>
-      With Google Play for Education, teachers and administrators can browse
+
+
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-6of12">
+      <h2 id="maximize_your_ad_revenue">For developers</h2>
+      <img src="{@docRoot}images/gpfe-developer.png">
+      <h5>Get discovered</h5>
+      <p>With Google Play for Education, teachers and administrators can browse
       content by curriculum, grade, and standard &mdash; discovering the right
       content for their students. If your app offers an exciting new way to
       learn sixth grade algebra, math educators will be able to find, purchase,
-      and distribute your app to their classes in a few clicks.
-    </p>
-    <b>Reach more schools and students</b>
+      and distribute your app to their classes in a few clicks.</p>
+      <h5>Reach more schools and students</h5>
     <p>
       Millions of students, faculty, and staff are using Google Apps for
       Education and other Google services. Many of these schools are excited to
@@ -52,55 +54,52 @@
       looking to bring your apps into their classrooms, especially apps using
       Google sign-on.
     </p>
-    <b>Monetize effectively</b>
+      <h5>Monetize effectively</h5>
     <p>
       With Google Play for Education, educators are able to make high-volume
       purchases using standard institutional payment mechanisms and then
       distribute apps to the students who need them — whether it’s a class of
       20 or a district of 20,000.
     </p>
-  </div>
-
-  <div style="width:48%; margin-left:2%; float:left;">
-    <div class="centered-full-image">
-      <img src="{@docRoot}images/gpfe-educator.png">
     </div>
 
-    <h3>
-      FOR EDUCATORS
-    </h3>
-    <b>Android tablets in the classroom</b>
+
+    <div class="col-6of12">
+      <h2 id="maximize_your_ad_revenue">For educators</h2>
+      <img src="{@docRoot}images/gpfe-educator.png">
+      <h5>    <b>Android tablets in the classroom</h5>
     <p>
       Google Play for Education brings the innovation of Android technology
       into classrooms. School districts can set up and deploy large numbers of
       devices in just minutes or hours, rather than days.
     </p>
-    <b>Curriculum-based discovery</b>
+      <h5>Curriculum-based discovery</h5>
     <p>
       Powerful browsing tools let educators quickly discover apps, videos, and
       other content—with many recommended by teachers and categorized according
       to familiar Core Curriculum standards.
     </p>
-    <b>Bulk purchase with institutional payment</b>
+      <h5>Bulk purchase with institutional payment</h5>
     <p>
       Convenient purchasing and delivery tools let educators buy apps in bulk,
       using purchase orders and other payment methods that are easy for schools
       to manage.
     </p>
-    <b>Over-the-air delivery to student devices</b>
+      <h5>Over-the-air delivery to student devices</h5>
     <p>
       After finding apps they want, educators can push them instantly to
       student devices over the air. They can send the apps to individuals or
       groups of any size, across classrooms, schools, or even districts.
     </p>
+      <h5>Business-wide licensing</h5>
+      <p>Paid apps are licensed to your organization, enabling you to move paid apps between users as users needs change and staff turns over. </p>
+    </div>
   </div>
 </div>
 
-<p style="clear:both">
-</p>
-<div class="headerLine">
+
 <h2 id="related-resources">Related Resources</h2>
-</div>
+
 
 <div class="dynamic-grid">
 
diff --git a/docs/html/distribute/googleplay/families/faq.jd b/docs/html/distribute/googleplay/families/faq.jd
index 9f916a8..363dc91 100644
--- a/docs/html/distribute/googleplay/families/faq.jd
+++ b/docs/html/distribute/googleplay/families/faq.jd
@@ -1,4 +1,4 @@
-page.title=Frequently Asked Questions
+page.title=Google Play for Families FAQ
 meta.tags="families", "guidelines", "quality"
 page.tags="families", "addendum"
 page.metaDescription=Questions and answers about Designed for Families
diff --git a/docs/html/distribute/googleplay/googleplay_toc.cs b/docs/html/distribute/googleplay/googleplay_toc.cs
index 8a321bb..4ddc489 100644
--- a/docs/html/distribute/googleplay/googleplay_toc.cs
+++ b/docs/html/distribute/googleplay/googleplay_toc.cs
@@ -84,6 +84,12 @@
         </a></li>
     </ul>
   </li>
+  <li class="nav-section">
+    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/googleplay/work/about.html">
+          <span class="en"><span style="white-space:nowrap">Google Play for Work</span></span>
+        </a>
+    </div>
+  </li>
 </ul>
 <script type="text/javascript">
 <!--
diff --git a/docs/html/distribute/googleplay/index.jd b/docs/html/distribute/googleplay/index.jd
index 72e2de8..1908e01 100644
--- a/docs/html/distribute/googleplay/index.jd
+++ b/docs/html/distribute/googleplay/index.jd
@@ -11,9 +11,7 @@
   help you gain traction in the marketplace.</span>
 </p>
 
-<div class="dynamic-grid">
-
-  <h3>Overview</h3>
+  <h2>Overview</h2>
 
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/gp/gplanding"
@@ -22,25 +20,20 @@
     data-maxResults="3">
   </div>
 
-  <h3>Distribute Your Apps</h3>
+  <h2>Distribute Your Apps</h2>
 
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/gp/gpfelanding"
     data-cardSizes="6x6"
-    data-maxResults="5">
+    data-maxResults="10">
   </div>
 
-  <h3>Related resources</h3>
+<!--  <h2>Related resources</h2>
 
   <div class="resource-widget resource-flow-layout col-16"
-    data-query="type:youtube+tag:growth"
-    data-cardSizes="6x3"
-    data-maxResults="3">
-  </div>
-  <div class="resource-widget resource-flow-layout col-16"
-    data-query="type:blog+tag:googleplay"
-    data-cardSizes="6x3"
-    data-maxResults="3">
-  </div>
+    data-query="tag:growth"
+    data-cardSizes="6x2"
+    data-maxResults="3"
+    data-sortOrder="random">
+  </div> -->
 
-</div>
diff --git a/docs/html/distribute/googleplay/work/about.jd b/docs/html/distribute/googleplay/work/about.jd
new file mode 100644
index 0000000..6ced561
--- /dev/null
+++ b/docs/html/distribute/googleplay/work/about.jd
@@ -0,0 +1,95 @@
+page.title=Google Play for Work
+page.metaDescription=Distribute your apps directly to enterprises and business users.
+page.tags="enterprise", "emm", "business", "administrator"
+page.image=images/distribute/android-work.jpg
+@jd:body
+
+<p>Google Play for Work is an extension of Google Play that lets Android for Work users browse and install apps. IT admins in a business using Android for Work choose which public and private apps are made available to users in their business. Businesses can use Google Play for Work to securely bulk deploy free apps to their employees or bulk purchase paid apps depending on their needs.</p>
+
+<p>As a Google Play developer, your free apps are automatically ready to be selected by Android for Work customers and made available to their workforces on Google Play for Work. However, to allow businesses access to bulk purchase your paid apps, you must opt-in and agree to the <a href="https://play.google.com/about/work/developer-distribution-agreement-addendum.html">Google Play for Work Addendum</a> to the Developer Distribution Agreement.</p>
+
+<p>Find out more about <a href="">distributing to Google Play for Work</a>.</p>
+
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-6of12">
+      <h2 id="maximize_your_ad_revenue">For developers</h2>
+      <img src="{@docRoot}images/distribute/gpfw_developer.png">
+      <h5>Get discovered</h5>
+      <p>Get your business related apps listed in a business specific gateway so they stand out from consumer apps.</p>
+      <h5>Get volume</h5>
+      <p>Reach new audiences at scale because businesses will be able to deploy your free apps in bulk. Bulk purchasing also allows businesses to buy your paid app at scale.</p>
+      <h5>Generate revenue from extended support</h5>
+      <p>Businesses will often look for extended support for business critical apps, and you have the opportunity to offer that support for a fee.</p>
+      <h5>Continue to offer in app-purchases</h5>
+      <p>You can continue to offer free apps with in-app purchases. Business employees will be able to make purchases just as they would if they personally installed your app. </p>
+    </div>
+
+
+    <div class="col-6of12">
+      <h2 id="maximize_your_ad_revenue">For businesses</h2>
+      <img src="{@docRoot}images/distribute/gpfw_business.png">
+      <h5>Free to businesses</h5>
+      <p>Google Play for Work is available free of charge to Android for Work customers.</p>
+      <h5>Full IT approval for apps</h5>
+      <p>IT can now approve and manage every app deployed to its organization’s workers.</p>
+      <h5>Secure app distribution</h5>
+      <p>Provides a secure gateway for distributing apps within your company, whether they are available publicly or distributed privately to employees at your organization.</p>
+      <h5>Work app configuration</h5>
+      <p>Maintain app settings, such as server addresses and default user settings, from your admin console for enabled apps.</p>
+      <h5>Business-wide licensing</h5>
+      <p>Paid apps are licensed to your organization, enabling you to move paid apps between users as users needs change and staff turns over. </p>
+    </div>
+  </div>
+</div>
+
+<h2 id="best_practices">Best practices for success</h2>
+
+<p>Keep these best practices in mind as you build a great enterprise-ready app.</p>
+
+<h3 id="design">Build a great app for business</h3>
+
+<ul>
+  <li>Follow best practices for security and manage user data properly. Businesses
+  are more conscious of data security and employee productivity, especially when it
+  comes to features that share information with other services.</li>
+  <li>Support the Work App Configuration framework to let an administrator remotely configure app settings such as:
+    <ul>
+      <li>Server address and protocol settings</li>
+      <li>The ability to switch features on and off</li>
+      <li>Sign-in credentials for your app's backend servers</li>
+      <li>Default user settings</li>
+    </ul>
+  </li>
+  <li>Request the minimum permissions that your app needs.</li>
+  <li>Make sure communication to your backend and data in your backend is secure.</li>
+  <li>Implement authorization policies that will minimize the number of your employees that can access user data.</li>
+  <li><a href={@docRoot}training/enterprise/app-compatibility.html">Offer compatibility with managed profile</a> and test that with the <a href="{@docRoot}samples/BasicManagedProfile/index.html">BasicManagedProfile sample app</a>.</li>
+  <li>Support <a href="{@docRoot}training/enterprise/app-restrictions.html">app restrictions</a> so that IT admins can remotely configure your app through leading EMM solutions.</li>
+</ul>
+
+<!--<h3 id="distribute">Distribute</h3>
+
+<p>Free to install apps are automatically made available through Google Play for Work, but for paid apps:</p>
+
+<ul>
+<li>When you <a href="https://support.google.com/googleplay/android-developer/answer/113469">publish your app through the Developer Console</a>, opt in to distribute through Google Play for Work, so you agree to your app’s licenses being transferrable within a single business customer.</li>
+<li>Use the <a href="{@docRoot}}google/play/licensing/index.html">Licensing API to track which users have licenses assigned.</li>
+</ul> -->
+
+
+<h3 id="support">Provide support and maintenance</h3>
+
+<ul>
+<li>Consider offering enhanced support to cover extended hours or specific means of contact. Businesses are often willing to pay for this service.</li>
+<li>If you update the App Configuration / App Restrictions schema for your app, make sure it remains backward compatible. This is because it’s possible that different users will have different versions of your app (at least temporarily), and IT admin will want a consistent remote configuration experience between versions to ensure efficient management of apps in the field.</li>
+</ul>
+
+<h2 id=related_resources>Related resources</h2>
+
+<div class="resource-widget resource-flow-layout col-13"
+  data-query="collection:distribute/googleplay/gpfw"
+  data-sortOrder="-timestamp"
+  data-cardSizes="9x3"
+  data-maxResults="6"></div>
+
diff --git a/docs/html/distribute/index.jd b/docs/html/distribute/index.jd
index ce64445..d3f3836 100644
--- a/docs/html/distribute/index.jd
+++ b/docs/html/distribute/index.jd
@@ -22,7 +22,7 @@
       data-query="type:youtube+tag:googleplay+tag:developerstory+tag:featured, type:blog+tag:googleplay+tag:distribute+tag:featured"
       data-sortOrder="-timestamp"
       data-cardSizes="6x6"
-      data-maxResults="6"></div>
+      data-maxResults="3"></div>
 </div></section>
 
 <section class="dac-section dac-invert dac-darken-bg" style="background-image: url(/images/distribute/google-play-bg.jpg)"><div class="wrap">
@@ -64,7 +64,11 @@
     </a></li>
     <li class="dac-section-link"><a href="/distribute/monetize/index.html">
       <span class="dac-sprite dac-auto-chevron"></span>
-      Monetize
+      Earn
+    </a></li>
+    <li class="dac-section-link"><a href="/distribute/analyze/index.html">
+      <span class="dac-sprite dac-auto-chevron"></span>
+      Analyze
     </a></li>
   </ul>
 </div></section>
@@ -77,10 +81,10 @@
   <div class="resource-widget resource-flow-layout col-16"
        data-query="collection:distribute/landing/more"
        data-cardSizes="6x6"></div>
-  <ul class="dac-section-links">
+<!--  <ul class="dac-section-links">
     <li class="dac-section-link"><a href="https://developers.google.com/">
       <span class="dac-sprite dac-auto-chevron"></span>
       More Google services for Android
     </a></li>
-  </ul>
+  </ul> -->
 </div></section>
diff --git a/docs/html/distribute/monetize/ads.jd b/docs/html/distribute/monetize/ads.jd
index 8f6c8b0..c15f2bb 100644
--- a/docs/html/distribute/monetize/ads.jd
+++ b/docs/html/distribute/monetize/ads.jd
@@ -25,89 +25,88 @@
 </ul>
 
 <p><a href="http://www.google.com/ads/admob/#subid=us-en-et-dac">Sign-up for AdMob</a>
-today and start showing ads by integrating the <a
-href="https://developers.google.com/mobile-ads-sdk/download">Google Mobile Ads SDK</a>
+today and start using the <a
+href="https://developer.android.com/google/play-services/ads.html">Google Mobile Ads SDK</a>
 in your app with a few lines of code.</p>
 
-<h2 id="key_features">Key features</h2>
+<h2 id="maximize_your_ad_revenue">Maximize your ad revenue</h2>
 
-<div style="display:inline-block">
-<h3 id="maximize_your_ad_revenue">Maximize your ad revenue</h3>
-
-<div class="col-4">
-  <h4 id="maximize_earnings">Maximize earnings</h4>
-  <p>Earn more with our industry-leading ad service, which includes <a href=
-  "https://support.google.com/admob/answer/3063564">free mediation</a> to
-  automatically improve your earnings, and access to all of Google’s advertiser
-  demand from AdMob, AdWords, and the DoubleClick Ad Exchange.</p>
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-4of12">
+      <h5 id="maximize_earnings">Maximize earnings</h5>
+      <p>Earn more with our industry-leading ad service, which includes <a href=
+      "https://support.google.com/admob/answer/3063564">free mediation</a> to
+      automatically improve your earnings, and access to all of Google’s advertiser
+      demand from AdMob, AdWords, and the DoubleClick Ad Exchange.</p>
+    </div>
+    <div class="col-4of12">
+      <h5 id="get_paid_fast">Get paid fast</h5>
+      <p>Get paid in local currencies quickly and reliably, with no wire fees charged by
+      AdMob.</p>
+    </div>
+    <div class="col-4of12">
+      <h5 id="easy_and_free">Easy and free</h5>
+      <p>The SDK can be installed quickly, and there are no standard fees for using the
+      platform.</p>
+    </div>
+  </div>
 </div>
 
-<div class="col-4">
-  <h4 id="get_paid_fast">Get paid fast</h4>
-  <p>Get paid in local currencies quickly and reliably, with no wire fees charged by
-  AdMob.</p>
+<h2 id="grow_your_business_with_a_trusted_partner">Grow your business with a trusted partner</h2>
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-6of12">
+      <h5 id="powered_by_googles_ad_technology">Powered by Google’s ad technology</h5>
+      <p>For over a decade, Google has helped millions of developers grow their digital
+      businesses.</p>
+    </div>
+    <div class="col-6of12">
+      <h5 id="auto_updates_on_google_play">Auto updates on Google Play</h5>
+      <p>AdMob’s integration with Google Play services pushes automatic performance
+        improvements to Android apps without additional SDK changes.</p>
+    </div>
+  </div>
 </div>
 
-<div class="col-4">
-  <h4 id="easy_and_free">Easy and free</h4>
-  <p>The SDK can be installed quickly, and there are no standard fees for using the
-  platform.</p>
-</div>
-</div>
 
-<div style="display:inline-block">
-<h3 id="grow_your_business_with_a_trusted_partner">Grow your business with a trusted partner</h3>
-
-<div class="col-6">
-  <h4 id="powered_by_googles_ad_technology">Powered by Google’s ad technology</h4>
-  <p>For over a decade, Google has helped millions of developers grow their digital
-  businesses.</p>
-</div>
-
-<div class="col-6">
-<h4 id="auto_updates_on_google_play">Auto updates on Google Play</h4>
-<p>AdMob’s integration with Google Play services pushes automatic performance
-  improvements to Android apps without additional SDK changes.</p>
-</div>
-</div>
-
-<div style="display:inline-block">
-<h3 id="drive_more_in-app_purchases_and_downloads">Drive more in-app purchases and downloads</h3>
-
-<div class="col-6">
-<h4 id="sell_more_in-app_purchases">Sell more in-app purchases</h4>
+<h2 id="drive_more_in-app_purchases_and_downloads">Drive more in-app purchases and downloads</h2>
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-6of12">
+<h5 id="sell_more_in-app_purchases">Sell more in-app purchases</h5>
 <p>Earn more revenue by intelligently promoting your in-app purchases to the users
 most likely to buy them.</p>
-</div>
-
-<div class="col-6">
-<h4 id="promote_your_apps_for_free">Promote your apps for free</h4>
+    </div>
+    <div class="col-6of12">
+<h5 id="promote_your_apps_for_free">Promote your apps for free</h5>
 <p>Cross-sell your other apps (or your friend’s apps) to your existing users,
 using free AdMob <a href="https://support.google.com/admob/answer/3210452">house ads</a>.</p>
-</div>
+    </div>
+  </div>
 </div>
 
-<div style="display:inline-block">
-<h3 id="drive_more_in-app_purchases_and_downloads">Drive more in-app purchases and downloads</h3>
-
-<div class="col-6">
-<h4 id="analytics_for_apps">Analytics for apps</h4>
+<h2 id="understand_users">Understand your users</h2>
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-6of12">
+<h5 id="analytics_for_apps">Analytics for apps</h5>
 <p>Analyze your app’s performance from within AdMob with Google Analytics.
 Discover where people are downloading your app, and the features they use the
 most in real time.</p>
-</div>
-
-<div class="col-6">
-<h4 id="flow_visualization_reports">Flow visualization reports</h4>
+    </div>
+    <div class="col-6of12">
+<h5 id="flow_visualization_reports">Flow visualization reports</h5>
 <p>In Analytics, see how people are navigating through your app with graphical
 <a href="https://support.google.com/analytics/answer/2519986">flow reports</a>.
 View the path they take to making a purchase, and the point where they exit
 the app, plus much more.</p>
-</div>
+    </div>
+  </div>
 </div>
 
 
-<h2 id=tips>Tips</h2>
+<div style="<h2 id=tips>Tips</h2>
 
 <ul>
   <li> Place ads wisely, they shouldn't be too intrusive but still need to be clearly
diff --git a/docs/html/distribute/monetize/index.jd b/docs/html/distribute/monetize/index.jd
index 7350a24..dc5c704 100644
--- a/docs/html/distribute/monetize/index.jd
+++ b/docs/html/distribute/monetize/index.jd
@@ -1,4 +1,4 @@
-page.title=Monetize
+page.title=Earn
 section.landing=true
 nonavpage=true
 
@@ -17,20 +17,17 @@
   help you track where your money is coming from.
 </p>
 
-<div class="dynamic-grid">
-
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/monetize"
     data-cardSizes="6x6"
     data-maxResults="9">
   </div>
 
-<h3>Related resources</h3>
+<!-- <h2>Related resources</h2>
 
   <div class="resource-widget resource-flow-layout col-16"
     data-query="tag:monetizing"
-    data-sortOrder="-timestamp"
-    data-cardSizes="6x3"
-    data-maxResults="6">
-  </div>
-</div>
+    data-cardSizes="6x2"
+    data-sortOrder="random"
+    data-maxResults="3">
+  </div> -->
\ No newline at end of file
diff --git a/docs/html/distribute/monetize/payments.jd b/docs/html/distribute/monetize/payments.jd
index 55c289f..187f872 100644
--- a/docs/html/distribute/monetize/payments.jd
+++ b/docs/html/distribute/monetize/payments.jd
@@ -1,5 +1,5 @@
 page.title=Convenient, Frictionless Purchasing
-page.image=/distribute/images/payment-method.jpg
+page.image=
 page.metaDescription=Users can purchase instantly with a choice of payment methods.
 page.tags="google play", "payments", "gift card"
 
diff --git a/docs/html/distribute/tools/index.jd b/docs/html/distribute/tools/index.jd
index c8f0212..24c3398 100644
--- a/docs/html/distribute/tools/index.jd
+++ b/docs/html/distribute/tools/index.jd
@@ -9,49 +9,39 @@
   users, and monetize your investment.
 </p>
 
-<div class="dynamic-grid">
-
-  <h3>Publishing and Launch</h3>
+  <h2>Publishing and Launch</h2>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/tools/checklists"
     data-cardSizes="9x6"
     data-maxResults="2">
   </div>
 
-<h3>Marketing Tools</h3>
+  <h2>Marketing Tools</h2>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/tools/promote"
     data-cardSizes="6x6"
     data-maxResults="3">
   </div>
 
-  <h3>Developer Support</h3>
+  <h2>Developer Support</h2>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/tools/support"
     data-cardSizes="6x6"
     data-maxResults="3">
   </div>
 
-  <h3>Developer News</h3>
+  <h2>Developer News</h2>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/tools/news"
     data-cardSizes="9x6"
     data-maxResults="2">
   </div>
 
-  <h3>More</h3>
+  <h2>More</h2>
   <div class="resource-widget resource-flow-layout landing col-16"
     data-query="collection:distribute/tools/more"
     data-cardSizes="6x6"
     data-maxResults="3">
   </div>
 
-<!--  <h3>Related Resources</h3>
-  <div class="resource-widget resource-stack-layout col-16"
-    data-query="tag:developersupport"
-    data-sortOrder="-timestamp"
-    data-numStacks="3"
-    data-maxResults="6">
-  </div> -->
 
-</div>
diff --git a/docs/html/distribute/users/house-ads.jd b/docs/html/distribute/users/house-ads.jd
new file mode 100644
index 0000000..d662fb2
--- /dev/null
+++ b/docs/html/distribute/users/house-ads.jd
@@ -0,0 +1,61 @@
+page.title=Cross-Sell to Users with House Ads
+page.metaDescription=Tap into your existing user base to increase downloads and increase conversions.
+page.tags="google", "identity", "signin"
+page.image=distribute/images/advertising.jpg
+
+@jd:body
+
+<p>One of the fastest ways to accumulate downloads or increase conversions is to tap into your
+existing user base. These users know your products and are a receptive audience for your other
+apps and in-app products.</p>
+
+<h3>Promote your apps for free</h3>
+
+<p>AdMob's house ads let you cross-sell your other apps (or your friend’s apps) to your
+existing users, and it's a free service.</p>
+
+<h3>Sell more in-app purchases</h3>
+
+<p>Intelligently promote your in-app purchases to the users most likely to buy them, with
+AdMob’s free in-app purchase house ad format.</p>
+
+<p>Get started <a href="https://developers.google.com/identity/sign-in/">integrating
+Google sign-in into your apps and games</a>.</p>
+
+<div class="wrap">
+  <div class="cols" style="margin:1em auto;">
+    <div class="col-8of12">
+     <img src="{@docRoot}images/distribute/house-ads.png" style="padding-top:1em;">
+    </div>
+  </div>
+</div>
+
+<p><a href="http://www.google.com/ads/admob/#subid=us-en-et-dac">Sign-up for AdMob</a> today
+and start using the <a href="https://developer.android.com/google/play-services/ads.html">Google
+Mobile Ads SDK</a> included in Google Play services to show ads in your app with a few lines of
+code. Then create your <a href="https://support.google.com/admob/answer/3210442?hl=en">house
+ad campaigns</a>.</p>
+
+<h2>Tips</h2>
+
+<ul>
+  <li>AdMob automatically figures out which of your users are likely to spend to optimize which
+  users see the ads.</li>
+  <li>Place ads wisely, they shouldn't be too intrusive but still need to be clearly visible to
+  attract clickthroughs.</li>
+  <li>Remember that ads form part of your app and must match its age rating.</li>
+  <li>Use the impression goals feature of AdMob house ads to set limits on the number of ads
+  served. This is useful if you want to run ad campaigns in your app from other developers.</li>
+</ul>
+
+
+<h2 style="clear:both" id="related-resources">Related Resources</h2>
+
+<div class="resource-widget resource-flow-layout col-13"
+  data-query="collection:distribute/users/houseads"
+  data-sortorder="-timestamp"
+  data-cardsizes="6x3"
+  data-maxresults="6">
+</div>
+
+
diff --git a/docs/html/distribute/users/index.jd b/docs/html/distribute/users/index.jd
index a810f36..a3f8d01 100644
--- a/docs/html/distribute/users/index.jd
+++ b/docs/html/distribute/users/index.jd
@@ -10,21 +10,23 @@
   developers. These best practices are critical to your app or game’s success.
 </p>
 
-<div class="dynamic-grid">
-
 <div class="resource-widget resource-flow-layout landing col-16"
   data-query="collection:distribute/users"
   data-cardSizes="6x6"
   data-maxResults="6">
 </div>
+<div class="resource-widget resource-flow-layout landing col-16"
+  data-query="collection:distribute/users"
+  data-cardSizes="9x3"
+  data-maxResults="16">
+</div>
 
-<h3>Related resources</h3>
+<!-- <h2>Related resources</h2>
 
   <div class="resource-widget resource-flow-layout col-16"
-    data-query="type:youtube+tag:users,tag:global,type:blog+tag:users"
-    data-sortOrder="-timestamp"
-    data-cardSizes="6x3"
-    data-maxResults="6">
-  </div>
-  
-</div>
+    data-query="tag:users"
+    data-sortOrder="random"
+    data-cardSizes="6x2"
+    data-maxResults="3">
+  </div> -->
+
diff --git a/docs/html/distribute/users/ota-installs.jd b/docs/html/distribute/users/ota-installs.jd
new file mode 100644
index 0000000..e7afd64
--- /dev/null
+++ b/docs/html/distribute/users/ota-installs.jd
@@ -0,0 +1,51 @@
+page.title=Offer Over-the-air Installs
+page.metaDescription=Let users send your app directly to their devices when they sign in with Google.
+page.tags="google", "identity", "installs"
+page.image=images/cards/google-sign-in_2x.png
+
+
+@jd:body
+
+<p>Google sign-in is a trusted registration system that's familiar to users and
+consistent across devices. With minimal effort, you can improve your sign-in conversion
+with a fast and secure authentication option for users. And by using Google sign-in,
+you can offer users the option to send your app directly to their Android devices when
+they sign-in, without the need for them to visit the Play store. Using this approach,
+some developers have seen app installation acceptance rates of 40%.</p>
+
+<p>Get started with <a href="https://developers.google.com/identity/sign-in/android/">
+Google sign-in for Android/a> and then enable <a
+href="https://developers.google.com/identity/sign-in/web/android-app-installs">over-the-air
+installs</a> for your web site.</p>
+
+<div class="wrap">
+  <div class="cols" style="margin-top:2em;">
+    <div class="col-8of12 col-push-1of12">
+     <img src="{@docRoot}images/distribute/ota-installs.gif">
+    </div>
+  </div>
+</div>
+
+
+<h2>Tips</h2>
+
+<ul>
+  <li>Adding Google sign-in to your app can increase conversions by reducing the burden
+  and friction of sign-in, while helping users keep their accounts secure.</li>
+  <li>Focus on the quality of your app to ensure that it passes the quality threshold for
+  over-the-air installation.</li>
+  <li>Measure impressions of the Android install prompt, installs, and success rate by
+  day, week, and month with Platform Insights.</li>
+</ul>
+
+
+<h2 style="clear:both" id="related-resources">Related Resources</h2>
+
+<div class="resource-widget resource-flow-layout col-13"
+  data-query="collection:distribute/users/otas"
+  data-sortorder="-timestamp"
+  data-cardsizes="9x3"
+  data-maxresults="4">
+</div>
+
+
diff --git a/docs/html/distribute/users/promote-with-ads.jd b/docs/html/distribute/users/promote-with-ads.jd
index d71b8c9..3456c66 100644
--- a/docs/html/distribute/users/promote-with-ads.jd
+++ b/docs/html/distribute/users/promote-with-ads.jd
@@ -11,56 +11,67 @@
 
 <h2 id=drive_installs>Drive installs</h2>
 
-<p><a href="http://adwords.google.com">AdWords</a> promotes your app to interested users where they spend time on phones and
+<p><a href="http://adwords.google.com">AdWords</a> promotes your app to interested
+users where they spend time on phones and
 tablets – with app install ads on Google Search, YouTube, Gmail, and within
 apps and across the web on  the Google Display Network. AdWords is a powerful
 way to scale app promotion across Google networks and find customers that are
 most likely to install your app. </p>
 
-<p><a href="https://support.google.com/adwords/answer/6032059">Get started with AdWords app install ads</a>.</p>
+<p><a href="https://support.google.com/adwords/answer/6032059">Get started with AdWords
+app install ads</a>.</p>
 
-<div style="display:inline-block">
- <div class="figure-left" style="width:40%;">
+
+
+<div class="wrap">
+  <div class="cols" style="margin-top:1em;">
+    <div class="col-4of12">
    <h3>From Google Play</h3>
-   <img src="/images/distribute/promote_ads_play.png">
-    <p class="figure-caption">Search ads on Google Play are still undergoing testing and not yet available to
-buy. <a href="http://android-developers.blogspot.com/2015/02/a-new-way-to-promote-your-app-on-google.html">Find out more</a>.</p>
-  </div>
-  <div class="figure-right" style="width:40%;">
-    <h3>From apps</h3>
+    <img src="/images/distribute/promote_ads_play.png">
+    <p class="figure-caption">Search ads on Google Play are still undergoing testing and
+    not yet available to buy. <a
+    href="http://android-developers.blogspot.com/2015/02/a-new-way-to-promote-your-app-on-google.html">Find
+    out more</a>.</p>
+    </div>
+    <div class="col-4of12">
+  <h3>From search</h3>
     <img src="/images/distribute/promote_ads_search.png">
-    <p class="figure-caption">Connect with users as they search for content and services provided by your
-app.</p>
-  </div>
-</div>
-
-<div style="display:inline-block">
- <div class="figure-left" style="width:40%;">
+    <p class="figure-caption">Connect with users as they search for content and services
+    provided by your app.</p>
+    </div>
+    <div class="col-4of12">
    <h3>From YouTube</h3>
    <img src="/images/distribute/promote_ads_youtube.png">
     <p class="figure-caption">Promote your app when users are watching related videos.</p>
+    </div>
   </div>
-  <div class="figure-right" style="width:40%;">
+</div>
+
+<div class="wrap">
+  <div class="cols" style="margin-top:1em;">
+    <div class="col-4of12">
     <h3>From apps</h3>
     <img src="/images/distribute/promote_ads_apps.png">
-    <p class="figure-caption">Reach users while they’re engaged with apps and games across the AdMob network.</p>
-  </div>
-</div>
-
-<div style="display:inline-block">
- <div class="figure-left" style="width:40%;">
+    <p class="figure-caption">Reach users while they’re engaged with apps and games across the
+    AdMob network.</p>
+    </div>
+    <div class="col-4of12">
    <h3>From the web</h3>
    <img src="/images/distribute/promote_ads_web.png">
-    <p class="figure-caption">Reach users while they’re engaged with websites across the Google Display Network.</p>
-  </div>
-  <div class="figure-right" style="width:40%;">
+    <p class="figure-caption">Reach users while they’re engaged with websites across the Google
+    Display Network.</p>
+    </div>
+    <div class="col-4of12">
     <h3>From Gmail</h3>
     <img src="/images/distribute/promote_ads_gmail.png">
-    <p class="figure-caption">Promote your app while users communicate and get things done in Gmail.</p>
+    <p class="figure-caption">Promote your app while users communicate and get things done in
+    Gmail.</p>
+    </div>
   </div>
 </div>
 
-<h3>Tips</h3>
+
+<h2>Tips</h3>
 
 <ul>
   <li> Estimate how much an app user is worth to your business, so that you can work
@@ -89,21 +100,25 @@
 remind them of key features and encourage them to try your app again, or help
 them complete an activity they didn't know your app could handle.</p>
 
-<div>
- <div class="figure-left" style="width:46%;">
+
+<div class="wrap">
+  <div class="cols" style="margin-top:1em;">
+    <div class="col-4of12">
    <h3>From search</h3>
    <img src="/images/distribute/promote_ads.png">
     <p class="figure-caption">Add deep links to your app, then bring users straight
     to relevant app content when they’re searching.</p>
-  </div>
-  <div class="figure-right" style="width:46%;">
+    </div>
+    <div class="col-4of12">
     <h3>From apps</h3>
     <img src="/images/distribute/promote_ads_inapp.png">
     <p class="figure-caption">Use remarketing and deep links to bring users to just the right
     place in your app to re-engage and convert, from other apps and games they love.</p>
+    </div>
   </div>
 </div>
 
+
 <h3>Tips</h3>
 
 <ul>
diff --git a/docs/html/distribute/users/users_toc.cs b/docs/html/distribute/users/users_toc.cs
index 2e796c8..3aa3fe1 100644
--- a/docs/html/distribute/users/users_toc.cs
+++ b/docs/html/distribute/users/users_toc.cs
@@ -29,6 +29,24 @@
     </div>
   </li>
   <li class="nav-section">
+    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/users/ota-installs.html">
+          <span class="en">Offer Over-the-air Installs</span>
+        </a>
+    </div>
+  </li>
+  <li class="nav-section">
+    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/users/house-ads.html">
+          <span class="en">Cross-Sell to Users with House Ads</span>
+        </a>
+    </div>
+  </li>
+  <li class="nav-section">
+    <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/users/youtube.html">
+          <span class="en">Drive installs from YouTube</span>
+        </a>
+    </div>
+  </li>
+  <li class="nav-section">
     <div class="nav-section-header empty" style="font-weight:normal"><a href="<?cs var:toroot?>distribute/users/build-buzz.html">
           <span class="en">Build Buzz</span>
         </a>
diff --git a/docs/html/distribute/users/youtube.jd b/docs/html/distribute/users/youtube.jd
new file mode 100644
index 0000000..0be6584
--- /dev/null
+++ b/docs/html/distribute/users/youtube.jd
@@ -0,0 +1,34 @@
+page.title=Drive installs from YouTube
+page.metaDescription=Bring users from videos to your store listing with a merchandise card available on YouTube.
+page.image=images/cards/card-youtube_2x.png
+page.tags="users, youtube, cards, videos"
+@jd:body
+
+<p>Now you can bring users who discover your app videos on YouTube to your store listing with a merchandise card, one of several card types available to add to YouTube videos. Once published the presence of the merchandise card is indicated in the video with an information icon. When a viewer opens the card they follow the link to your app on the Play Store, where they can install your app.</p>
+
+<div class="wrap" style="margin:2em auto">
+  <div class="cols">
+    <div class="col-9of12">
+      <img src="{@docRoot}images/distribute/youtube-card-example.png">
+    </div>
+  </div>
+</div>
+
+<p>Get started <a href="https://support.google.com/youtube/answer/6140493">adding merchandise cards to your uploaded videos</a>.</p>
+
+<h2>Tips</h2>
+<ul>
+<li>Don’t indicate the location of a card within your video, cards might be positioned differently on different devices.</li>
+<li>When you add cards, featured video or playlist highlights in your video are hidden. </li>
+<li>In order to display cards, your account needs to be in good standing.</li>
+<li>Performance reporting for cards is available in YouTube Analytics.</li>
+<li>Cards work better when they're not too close to each other. Try spacing them out.</li>
+</ul>
+
+<h2 id="related-resources">Related resources</h2>
+
+<div class="resource-widget resource-flow-layout col-13"
+  data-query="collection:distribute/users/youtube"
+  data-sortOrder="-timestamp"
+  data-cardSizes="9x3"
+  data-maxResults="6"></div>
diff --git a/docs/html/google/index.jd b/docs/html/google/index.jd
index 1ebb9f8..364d5af 100644
--- a/docs/html/google/index.jd
+++ b/docs/html/google/index.jd
@@ -1,7 +1,7 @@
 fullpage=true
 page.title=Google Services
 section.landing=true
-meta.tags="beautifulapps, design, ux, patterns, holo, appquality, landing"
+meta.tags="google, play, services, maps, location, gcm, messaging, places"
 header.hide=1
 footer.hide=1
 @jd:body
@@ -16,14 +16,14 @@
       <div class="col-1of2 col-pull-1of2">
         <h1 class="dac-hero-title">Build better apps with Google</h1>
         <p class="dac-hero-description">
-        Add powerful capabilities to your apps, quickly, at low cost. Simplify development,
-grow your user base, and monetize more effectively with Google Play services. 
+        Add powerful capabilities, quickly, at low cost. Simplify development,
+        grow your user base, and monetize more effectively with Google Play services. 
         </p>
-        <a class="dac-hero-cta" href="https://www.google.com/design/spec/material-design/introduction.html">
+        <a class="dac-hero-cta" href="https://developers.google.com/android/guides/">
           <span class="dac-sprite dac-auto-chevron"></span>
           Get Started with Google Play services
         </a><br>
-        <a class="dac-hero-cta" href="https://www.google.com/design/spec/resources/color-palettes.html">
+        <a class="dac-hero-cta" href="https://developers.google.com/android/reference/">
           <span class="dac-sprite dac-auto-chevron"></span>
           API Reference
         </a><br>
@@ -42,20 +42,20 @@
     <i class="dac-sprite dac-arrow-down-gray"></i>
   </a>
 </div>
+
 <section class="dac-section dac-gray dac-small dac-invert" id="latest"><div class="wrap">
   <h2 class="norule">Latest</h2>
   <div class="resource-widget resource-flow-layout col-16"
        data-query="type:blog+tag:googleservices+tag:featured+tag:develop"
        data-cardSizes="6x6"
        data-maxResults="3"></div>
-</div></section>
-
-
+  </div>
+</section>
 
 <section class="dac-section dac-light"><div class="wrap">
   <h1 class="dac-section-title">Google APIs and services</h1>
   <div class="dac-section-subtitle">
-    Design around Android&apos;s capabilities and conventions to give users the best experience.
+    Google gives you a rich set of APIs to build with and delivers consistent services across billions of Android devices worldwide. 
   </div>
   <div class="resource-widget resource-flow-layout col-16"
        data-query="collection:google/landing/services"
@@ -67,17 +67,18 @@
       More Google services for Android
     </a></li>
   </ul>
-</div></section>
+  </div>
+</section>
 
 
 <section class="dac-section dac-invert dac-darken-bg" style="background-image: url(/images/distribute/google-play-bg.jpg)"><div class="wrap">
   <h1 class="dac-section-title">Google Play developer tools</h1>
   <div class="dac-section-subtitle">
-    Scale your operations. Essential downloads, stencils, and tools to help you create your design.
+    Scale your publishing operations, manage your catalog more easily, and build your revenue stream with in-app products and subscriptions using Google Play's developer tools. 
   </div>
   <div class="resource-widget resource-flow-layout col-16"
        data-query="collection:google/landing/googleplay"
-       data-cardSizes="6x6"
+       data-cardSizes="6x3"
        data-maxResults="6"></div>
 
   <ul class="dac-section-links">
diff --git a/docs/html/google/play/billing/billing_subscriptions.jd b/docs/html/google/play/billing/billing_subscriptions.jd
index 51fec09..e412a9d 100644
--- a/docs/html/google/play/billing/billing_subscriptions.jd
+++ b/docs/html/google/play/billing/billing_subscriptions.jd
@@ -1,7 +1,7 @@
 page.title=In-app Subscriptions
 parent.title=In-app Billing
 parent.link=index.html
-page.metaDescription=Subscriptions let you sell content or features in your app with automated, recurring billing.
+page.metaDescription=Create a steady revenue stream by selling subscriptions to your content.
 page.image=/images/play_dev.jpg
 page.tags="subscriptions, billing, inapp, iap"
 meta.tags="monetization, inappbilling, subscriptions"
diff --git a/docs/html/google/play/billing/index.jd b/docs/html/google/play/billing/index.jd
index c671c71..ae6e222 100644
--- a/docs/html/google/play/billing/index.jd
+++ b/docs/html/google/play/billing/index.jd
@@ -1,5 +1,5 @@
-page.title=Google Play In-app Billing
-page.metaDescription=In-app Billing lets you sell digital content as one-time purchases or subscriptions.
+page.title=In-app Billing
+page.metaDescription=Sell digital content as one-time purchases inside your app.
 page.image=/images/play_dev.jpg
 meta.tags="monetizing, inappbilling, subscriptions"
 page.tags="billing, inapp, iap"
@@ -24,7 +24,9 @@
     period.</li>
   <li><strong>IAB Sandbox</strong>&mdash;The In-app Billing Sandbox now supports
     testing subscription purchases.</li>
-  <li><strong>IAB v2 shutdown</strong>&mdash;In-app Billing v2 API is deprecated and will be shut down in January 2015. If your app is still using In-app Billing v2, please migrate to the v3 API as soon as possible.</li>
+  <li><strong>IAB v2 shutdown</strong>&mdash;In-app Billing v2 API is deprecated
+    and will be shut down in January 2015. If your app is still using In-app Billing
+    v2, please migrate to the v3 API as soon as possible.</li>
   <li><strong>Seasonal subscriptions</strong>&mdash;You can now set up a
     recurring <a href="billing_subscriptions.html#user-billing">seasonal
     subscription</a> that starts and ends on the same date each year (for
diff --git a/docs/html/images/cards/card-analytics_2x.png b/docs/html/images/cards/card-analytics_2x.png
new file mode 100644
index 0000000..da62659
--- /dev/null
+++ b/docs/html/images/cards/card-analytics_2x.png
Binary files differ
diff --git a/docs/html/images/cards/card-android-work_2x.png b/docs/html/images/cards/card-android-work_2x.png
new file mode 100644
index 0000000..ac8b9280
--- /dev/null
+++ b/docs/html/images/cards/card-android-work_2x.png
Binary files differ
diff --git a/docs/html/images/cards/card-youtube_2x.png b/docs/html/images/cards/card-youtube_2x.png
new file mode 100644
index 0000000..28bdd89
--- /dev/null
+++ b/docs/html/images/cards/card-youtube_2x.png
Binary files differ
diff --git a/docs/html/images/distribute/android-work.jpg b/docs/html/images/distribute/android-work.jpg
new file mode 100644
index 0000000..91f742b
--- /dev/null
+++ b/docs/html/images/distribute/android-work.jpg
Binary files differ
diff --git a/docs/html/images/distribute/gpfw_business.png b/docs/html/images/distribute/gpfw_business.png
new file mode 100644
index 0000000..d395b4e
--- /dev/null
+++ b/docs/html/images/distribute/gpfw_business.png
Binary files differ
diff --git a/docs/html/images/distribute/gpfw_developer.png b/docs/html/images/distribute/gpfw_developer.png
new file mode 100644
index 0000000..c0f0d26
--- /dev/null
+++ b/docs/html/images/distribute/gpfw_developer.png
Binary files differ
diff --git a/docs/html/images/distribute/house-ads.png b/docs/html/images/distribute/house-ads.png
new file mode 100644
index 0000000..f4df870
--- /dev/null
+++ b/docs/html/images/distribute/house-ads.png
Binary files differ
diff --git a/docs/html/images/distribute/ota-installs.gif b/docs/html/images/distribute/ota-installs.gif
new file mode 100644
index 0000000..85e40da
--- /dev/null
+++ b/docs/html/images/distribute/ota-installs.gif
Binary files differ
diff --git a/docs/html/images/distribute/signin-apps.png b/docs/html/images/distribute/signin-apps.png
new file mode 100644
index 0000000..9891acd
--- /dev/null
+++ b/docs/html/images/distribute/signin-apps.png
Binary files differ
diff --git a/docs/html/images/distribute/signin-seamless.png b/docs/html/images/distribute/signin-seamless.png
new file mode 100644
index 0000000..01b9d73
--- /dev/null
+++ b/docs/html/images/distribute/signin-seamless.png
Binary files differ
diff --git a/docs/html/images/distribute/signin-secure.png b/docs/html/images/distribute/signin-secure.png
new file mode 100644
index 0000000..3baad23
--- /dev/null
+++ b/docs/html/images/distribute/signin-secure.png
Binary files differ
diff --git a/docs/html/images/distribute/youtube-card-example.png b/docs/html/images/distribute/youtube-card-example.png
new file mode 100644
index 0000000..e5d77f9
--- /dev/null
+++ b/docs/html/images/distribute/youtube-card-example.png
Binary files differ
diff --git a/docs/html/images/play_dev.jpg b/docs/html/images/play_dev.jpg
index 6aae165..92513b7 100644
--- a/docs/html/images/play_dev.jpg
+++ b/docs/html/images/play_dev.jpg
Binary files differ
diff --git a/docs/html/images/play_dev_old.jpg b/docs/html/images/play_dev_old.jpg
new file mode 100644
index 0000000..6aae165
--- /dev/null
+++ b/docs/html/images/play_dev_old.jpg
Binary files differ
diff --git a/docs/html/images/versions/notification-headsup.png b/docs/html/images/versions/notification-headsup.png
index 7c374c8..623b225 100644
--- a/docs/html/images/versions/notification-headsup.png
+++ b/docs/html/images/versions/notification-headsup.png
Binary files differ
diff --git a/docs/html/images/versions/rivalknights.png b/docs/html/images/versions/rivalknights.png
index 6b467ef..6137fc4 100644
--- a/docs/html/images/versions/rivalknights.png
+++ b/docs/html/images/versions/rivalknights.png
Binary files differ
diff --git a/docs/html/index.jd b/docs/html/index.jd
index 71f6d58..c0a5b4b 100644
--- a/docs/html/index.jd
+++ b/docs/html/index.jd
@@ -1,5 +1,4 @@
 fullpage=true
-page.viewport_width=970
 excludeFromSuggestions=true
 page.metaDescription=The official site for Android developers. Provides the Android SDK and documentation for app developers and designers.
 page.customHeadTag=<meta name="google-site-verification" content="sa-bIAI6GKvct3f61-WpRguHq-aNjtF7xJjMTSi79as" />
@@ -31,13 +30,12 @@
   </div><!-- end .wrap -->
 </div><!-- end .actions-bar -->
 
-<div class="dac-hero-carousel" data-carousel-query="collection:distribute/landing/carousel">
-</div>
+
 
 <section class="dac-section dac-section-light" id="build-apps"><div class="wrap">
   <h1 class="dac-section-title">Build Beautiful Apps</h1>
   <div class="dac-section-subtitle">
-    See what’s new or find the resources to get you started with designing and developing for Android.
+    Resources to get you started with designing and developing for Android.
   </div>
   <div class="resource-widget resource-flow-layout col-16"
        data-query="collection:index/primary"
@@ -45,11 +43,14 @@
        data-maxResults="3"></div>
 </div></section>
 
+<div class="dac-hero-carousel" data-carousel-query="collection:distribute/landing/carousel">
+</div>
+
 <section class="dac-section dac-gray"><div class="wrap">
   <div class="cols"><div class="col-10of12 col-push-1of12">
     <h1 class="dac-section-title">Build for a Multi-Screen World</h1>
     <div class="dac-section-subtitle">
-      Android runs on hundreds of millions of handheld devices around the world,
+      Android runs on billions of handheld devices around the world,
       and it now supports these exciting, new form-factors.
     </div>
   </div></div>
diff --git a/docs/html/jd_collections.js b/docs/html/jd_collections.js
index a293131..3281179 100644
--- a/docs/html/jd_collections.js
+++ b/docs/html/jd_collections.js
@@ -123,10 +123,10 @@
     "resources": [
       "https://developers.google.com/analytics/devguides/collection/android/",
       "https://developers.google.com/maps/documentation/android/",
-      "https://developers.google.com/+/mobile/android/sign-in",
-      "https://developers.google.com/places/android/",
+      "https://developers.google.com/identity/sign-in/android/",
+      "https://developers.google.com/mobile-ads-sdk/download",
       "https://developers.google.com/gcm/android/",
-      "https://developers.google.com/maps/documentation/android/"
+      "https://developers.google.com/app-indexing/"
     ]
   },
   "google/landing/googleplay": {
@@ -203,7 +203,7 @@
       "http://youtu.be/vzvpcEffvaE"
     ]
   },
-  "launch/static": {
+/*  "launch/static": {
     "title": "",
     "resources": [
       "http://www.youtube.com/watch?v=1RIz-cmTQB4",
@@ -221,7 +221,7 @@
       "distribute/users/know-your-user.html",
       "distribute/googleplay/developer-console.html"
     ]
-  },
+  }, */
   "launch/static/ja": {
     "title": "",
     "resources": [
@@ -272,8 +272,18 @@
       "distribute/googleplay/auto.html",
       "distribute/googleplay/tv.html",
       "distribute/googleplay/wear.html",
+      "distribute/googleplay/cardboard.html",
+      "distribute/googleplay/cast.html",
       "distribute/googleplay/edu/about.html",
-      "distribute/googleplay/families/about.html"
+      "distribute/googleplay/families/about.html",
+      "distribute/googleplay/work/about.html"
+    ]
+  },
+  "distribute/googleplay/gpfw": {
+    "resources": [
+      "http://www.android.com/work/",
+      "https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "training/enterprise/index.html"
     ]
   },
   "distribute/essentials": {
@@ -304,6 +314,9 @@
       "distribute/users/expand-to-new-markets.html",
       "distribute/users/promote-with-ads.html",
       "distribute/users/appindexing.html",
+      "distribute/users/ota-installs.html",
+      "distribute/users/house-ads.html",
+      "distribute/users/youtube.html",
       "distribute/users/build-buzz.html",
       "distribute/users/build-community.html"
     ]
@@ -317,6 +330,7 @@
       "distribute/engage/deep-linking.html",
       "distribute/engage/ads.html",
       "distribute/engage/intents.html",
+      "distribute/engage/appindexing.html",
       "distribute/engage/analytics.html",
       "distribute/engage/game-services.html",
       "distribute/engage/app-updates.html",
@@ -630,7 +644,33 @@
     "resources": [
       "https://developers.google.com/app-indexing/",
       "https://developers.google.com/app-indexing/webmasters/details",
-      "distribute/engage/search.html"
+      "distribute/engage/appindexing.html"
+    ]
+  },
+  "distribute/users/otas": {
+    "title": "",
+    "resources": [
+      "https://developers.google.com/identity/sign-in/android/",
+      "https://developers.google.com/+/features/play-installs",
+      "https://developers.google.com/+/features/analytics"
+    ]
+  },
+  "distribute/users/houseads": {
+    "title": "",
+    "resources": [
+      "https://support.google.com/admob/topic/2784623",
+      "https://developers.google.com/mobile-ads-sdk/download",
+      "http://support.google.com/googleplay/android-developer/topic/2985714",
+      "http://analyticsacademy.withgoogle.com/mobile-app",
+      "https://support.google.com/analytics/answer/2611404",
+      "https://support.google.com/admob/answer/3111064"
+    ]
+  },
+  "distribute/users/youtube": {
+    "title": "",
+    "resources": [
+      "https://support.google.com/youtube/answer/6140493",
+      "https://support.google.com/youtube/answer/2797387"
     ]
   },
   "distribute/toolsreference/bestpractices/apps": {
@@ -910,10 +950,9 @@
   "distribute/engage/gplus": {
     "title": "",
     "resources": [
-      "google/play-services/plus.html",
-      "google/play-services/games.html",
-      "https://developers.google.com/+/mobile/android/share/interactive-post",
-      "https://developers.google.com/+/mobile/android/share/deep-link"
+      "distribute/users/ota-installs.html",
+      "https://developers.google.com/identity/sign-in/android/people",
+      "https://developers.google.com/+/mobile/android/"
     ]
   },
   "distribute/engage/community": {
@@ -1523,4 +1562,4 @@
       "samples/BasicManagedProfile/index.html"
     ]
   }
-}
+}
\ No newline at end of file
diff --git a/docs/html/jd_extras.js b/docs/html/jd_extras.js
index cf1da97..719be48 100644
--- a/docs/html/jd_extras.js
+++ b/docs/html/jd_extras.js
@@ -85,7 +85,7 @@
     "group":"",
     "keywords": ["carboard","vr"],
     "tags": [],
-    "image":"images/cards/card-cardboard_2x.jpg",
+    "image":"images/cards/card-cardboard_2x.png",
     "type":"Guide"
   },
     {
@@ -110,9 +110,6 @@
     "image":"images/cards/card-cardboard_2x.png",
     "type":"Design"
   },
-
-
-
   {
     "title":"Maps",
     "titleFriendly":"",
@@ -146,22 +143,6 @@
     "image":"images/gcm/gcm-logo.png",
     "type":"Guide"
   },
-   
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
   {
     "title":"ClassDojo Developer Story",
     "titleFriendly":"",
@@ -1243,27 +1224,13 @@
     "url": "http://www.google.com/analytics/mobile/",
     "timestamp": 1383243492000,
     "image": "images/cards/analytics-mobile_2x.jpg",
-    "title": "Google Mobile App Analytics",
+    "title": "Mobile App Analytics",
     "summary": "Mobile App Analytics measures what matters most at all key stages: from first discovery and download to in-app purchases. ",
     "keywords": ["analytics,user behavior"],
-    "type": "guide",
+    "type": "Guide",
     "titleFriendly": ""
   },
-  {
-    "lang": "en",
-    "group": "",
-    "tags": [
-      "#engagement",
-    ],
-    "url": "https://developers.google.com/app-indexing/",
-    "timestamp": 1383243492000,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/search_64dp.png",
-    "title": "Sign Up for App Indexing",
-    "summary": "Surface your app content in Google seaerch. Deep link direct to your apps.",
-    "keywords": [],
-    "type": "guide",
-    "titleFriendly": ""
-  },
+
 
   {
     "lang": "en",
@@ -1284,21 +1251,6 @@
     "lang": "en",
     "group": "",
     "tags": [
-      "#googleplus",
-    ],
-    "url": "https://developers.google.com/+/mobile/android/people",
-    "timestamp": 1383243492000,
-    "image": "images/google/gps-googleplus.png",
-    "title": "Google Sign In",
-    "summary": "After you let users sign in with Google, you can access their age range, language, public profile information, and people that they have circled.",
-    "keywords": ["googleplus"],
-    "type": "guide",
-    "titleFriendly": ""
-  },
-  {
-    "lang": "en",
-    "group": "",
-    "tags": [
       "#gcm",
     ],
     "url": "http://developer.chrome.com/apps/cloudMessagingV2",
@@ -1373,12 +1325,12 @@
     "lang": "en",
     "group": "",
     "tags": [],
-    "url": "https://developers.google.com/+/mobile/android/sign-in",
+    "url": "https://developers.google.com/+/mobile/android/",
     "timestamp": 1194884220000,
     "image": 'images/google/gps-googleplus.png',
-    "title": "Sign-in with Google",
-    "summary": "Get users into your app quickly and securely.",
-    "keywords": ["signin", "Google+"],
+    "title": "Google+ Platform",
+    "summary": "Find out about features such as interactive posts, Hangouts, accessing basic user details and their social graphs to make your app more personal.",
+    "keywords": ["Google+"],
     "type": "guide",
     "titleFriendly": ""
   },
@@ -1596,10 +1548,9 @@
     "tags": ["monetize", "ads"],
     "url": "http://support.google.com/googleplay/android-developer/topic/2985714",
     "timestamp": null,
-    "image": "http://storage.googleapis.com/support-kms-prod/SNP_712EA2784949DDF085C46E3BE7B1DC618A09_4389397_en_v0",
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/play_64dp.png",
+    "image":"images/play_dev.jpg",
     "title": "Policy Center: Ads",
-    "summary": "Introduction to ads and system interference policies in Google Play",
+    "summary": "Introduction to ads and system interference policies in Google Play.",
     "keywords": ["ads"],
     "type": "distribute",
     "titleFriendly": ""
@@ -1607,6 +1558,32 @@
   {
     "lang": "en",
     "group": "",
+    "tags": [],
+    "url": "https://support.google.com/analytics/answer/2611404",
+    "timestamp": null,
+    "image": "images/cards/analytics-mobile_2x.jpg",
+    "title": "Create Audience lists in Google Analytics",
+    "summary": "Find out how to use your analytics data to discover high value users and create remarketing audiences to use in AdMob.",
+    "keywords": ["ads, analytics, monetize"],
+    "type": "distribute",
+    "titleFriendly": ""
+  },
+  {
+    "lang": "en",
+    "group": "",
+    "tags": [],
+    "url": "https://support.google.com/admob/answer/3111064",
+    "timestamp": null,
+    "image": "distribute/images/advertising.jpg",
+    "title": "AdMob in-app conversion tracking",
+    "summary": "Use in-app conversion tracking to attribute revenue back to your IAP promotion campaigns and determine which ones earn you the most.",
+    "keywords": ["ads, analytics, conversions"],
+    "type": "distribute",
+    "titleFriendly": ""
+  },
+  {
+    "lang": "en",
+    "group": "",
     "tags": ["monetize", "giftcards"],
     "url": "https://play.google.com/about/giftcards/",
     "timestamp": null,
@@ -1676,7 +1653,7 @@
     "url": "https://developers.google.com/analytics/devguides/collection/android/",
     "timestamp": null,
     "image": "images/cards/analytics-mobile_2x.jpg",
-    "title": "Mobile App Analytics",
+    "title": "Mobile App Analytics SDK",
     "summary": "Measure everything about your app. Get started with the Google Analytics SDK for Android.",
     "keywords": ["analytics, user behavior"],
     "type": "sdk",
@@ -2395,7 +2372,7 @@
     "tags": [],
     "url": "https://support.google.com/adwords/answer/6032059",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "Setting up Mobile App Install Ads",
     "summary": "With Mobile app installs campaigns on the Search and Display Networks, and TrueView for mobile app promotion on YouTube, you can create custom app install ads that run exclusively on phones and tablets.",
     "keywords": ["marketing", "admob"],
@@ -2408,7 +2385,7 @@
     "tags": [],
     "url": "https://support.google.com/adwords/answer/6167164",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "Best practices for Mobile App Engagement",
     "summary": "Learn how to market to your user base to drive re-engagement with your app. ",
     "keywords": ["marketing", "admob"],
@@ -2452,23 +2429,15 @@
     "type": "distribute",
     "titleFriendly": ""
   },
-
-
-
-
-
-
-
-
   {
     "lang": "en",
     "group": "",
     "tags": [],
     "url": "https://support.google.com/admob/topic/2784623",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "Set up your AdMob account",
-    "summary": "Guide to setting up your account so that you get the most value.",
+    "summary": "Setting up your AdMob account in the right way will help you get the most value, check out the Setup and Basics guide.",
     "keywords": ["marketing", "admob"],
     "type": "distribute",
     "titleFriendly": ""
@@ -2479,7 +2448,7 @@
     "tags": [],
     "url": "http://analyticsacademy.withgoogle.com/mobile-app",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "Analytics Academy for Mobile Apps",
     "summary": "Learn how to use Google Analytics to make your app more discoverable and profitable.",
     "keywords": ["marketing", "analytics"],
@@ -2492,11 +2461,11 @@
     "tags": [],
     "url": "https://developers.google.com/mobile-ads-sdk/download",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
-    "title": "Google Mobile Ads SDK",
+    "image": "distribute/images/advertising.jpg",
+    "title": "Admob Ads",
     "summary": "Use the Mobile Ads SDK to start showing AdMob ads in your apps.",
     "keywords": ["marketing", "adwords"],
-    "type": "distribute",
+    "type": "Guide",
     "titleFriendly": ""
   },
   {
@@ -2505,7 +2474,7 @@
     "tags": [],
     "url": "https://support.google.com/admob/",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "AdMob Help Center",
     "summary": "For setup assistance, general info, and fixes for specific problems check out the AdMob Help Center.",
     "keywords": ["admob"],
@@ -2518,56 +2487,97 @@
     "tags": [],
     "url": "https://support.google.com/admob/answer/2753860",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/admob_64dp.png",
+    "image": "distribute/images/advertising.jpg",
     "title": "AdMob Policy Guidelines",
     "summary": "Learn about best practices for displaying AdMob ads in your apps to maximize revenue.",
     "keywords": ["admob"],
     "type": "distribute",
     "titleFriendly": ""
   },
+
   {
     "lang": "en",
     "group": "",
-    "tags": ["appindexing", "search", "getusers"],
+    "tags": [],
     "url": "https://developers.google.com/app-indexing/",
     "timestamp": 1383243492000,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/search_64dp.png",
+    "image": "images/cards/google-search_2x.png",
     "title": "Set Up App Indexing",
-    "summary": "Learn more about how Google Search can help users discover your app, along with other ways you can integrate with Google Search.",
-    "keywords": ["search"],
+    "summary": "Surface your app content in Google seaerch. Deep link direct to your apps.",
+    "keywords": ["search", "appindexing", "engagement", "getusers"],
     "type": "guide",
     "titleFriendly": ""
   },
-    {
+  {
     "lang": "en",
     "group": "",
-    "tags": ["appindexing", "search", "getusers"],
+    "tags": [],
     "url": "https://developers.google.com/app-indexing/webmasters/details",
     "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/search_64dp.png",
-    "title": "Verify and Create Deep Links",
-    "summary": "Index your app today by adding deep links and verifying its official web site to ensure it starts appearing in Google Search results.",
-    "keywords": ["search"],
+    "image": "images/cards/google-search_2x.png",
+    "title": "Index your app",
+    "summary": "Index your app today by adding deep links and verifying its official web site to ensure it starts appearing in Google Search results. ",
+    "keywords": ["appindexing","search","getusers"],
     "type": "distribute",
     "titleFriendly": ""
   },
-    {
+  {
     "lang": "en",
     "group": "",
-    "tags": [
-      "appindexing",
-      "search",
-      "getusers",
-    ],
-    "url": "https://support.google.com/admob/answer/2753860",
-    "timestamp": null,
-    "image": "https://www.gstatic.com/images/icons/material/product/2x/search_64dp.png",
-    "title": "Drive use with Google Search",
-    "summary": "More about how app indexing and deep links can drive users directly to the content in your app. ",
-    "keywords": [],
-    "type": "distribute",
+    "tags": [],
+    "url": "https://developers.google.com/identity/sign-in/android/people",
+    "timestamp": 1383243492000,
+    "image": "images/cards/google-sign-in_2x.png",
+    "title": "Get user profile details",
+    "summary": "After users sign-in with Google, you can access their age range, language, and public profile information.",
+    "keywords": ["signin", "identity", "google"],
+    "type": "guide",
     "titleFriendly": ""
   },
+
+
+  {
+    "lang": "en",
+    "group": "",
+    "tags": [],
+    "url": "https://developers.google.com/identity/sign-in/android/",
+    "timestamp": "",
+    "image": "images/cards/google-sign-in_2x.png",
+    "title": "Google Sign-In",
+    "summary": "Discover how you can enhance user experiences on your website or in your app using information provided by their Google identity.",
+    "keywords": ["signin", "identity", "google"],
+    "type": "guide",
+    "titleFriendly": ""
+  },
+  {
+    "lang": "en",
+    "group": "",
+    "tags": [],
+    "url": "https://developers.google.com/+/features/play-installs",
+    "timestamp": 1383243492000,
+    "image": "images/cards/google-sign-in_2x.png",
+    "title": "Over-the-air installs",
+    "summary": "Follow this step-by-step guide to quickly add Google Sign-in and over-the-air app installs to your website.",
+    "keywords": ["signin", "google", "installs"],
+    "type": "guide",
+    "titleFriendly": ""
+  },
+  {
+    "lang": "en",
+    "group": "",
+    "tags": [],
+    "url": "https://developers.google.com/+/features/analytics",
+    "timestamp": 1383243492000,
+    "image": 'images/google/gps-googleplus.png',
+    "title": "Google+ Insights",
+    "summary": "Measure impressions of the over-the-air install prompt, resulting installs, and success rate by day, week, and month.",
+    "keywords": ["signin", "identity"],
+    "type": "guide",
+    "titleFriendly": ""
+  },
+
+
+
  // TODO remove this?
   {
     "title":"Android Wear Materials",
@@ -2715,7 +2725,7 @@
   {
     "title":"Opportunities & Programs",
     "titleFriendly":"",
-    "summary":"This is a card body place holder text. This is a card body place holder text. This is a card body place holder text.",
+    "summary":"Take advantage of the many ways you can distribute your app to consumers, students, and businesses through Google Play.",
     "url":"distribute/googleplay/index.html#opportunities",
     "group":"",
     "keywords": [],
@@ -2725,6 +2735,56 @@
     "type":"distribute"
   },
   {
+    "title":"Android for Work",
+    "titleFriendly":"",
+    "summary":"Learn more about how Android for Work makes your favorite phones and tablets the perfect business tools.",
+    "url":"http://www.android.com/work/",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/cards/card-android-work_2x.png",
+    "lang":"en",
+    "type":"about"
+  },
+  {
+    "title":"Android for Work DevBytes",
+    "titleFriendly":"",
+    "summary":"Watch the videos in this playlist to understand more about Android for Work and get tips on developing enterprise apps.",
+    "url":"https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"http://i1.ytimg.com/vi/jQWB_-o1kz4/maxresdefault.jpg",
+    "lang":"en",
+    "type":"about"
+  },
+  {
+    "title":"Discover YouTube cards",
+    "titleFriendly":"",
+    "summary":"Find out more about YouTube cards, the options available, and how to use them to get the most from your YouTube content.",
+    "url":"https://support.google.com/youtube/answer/6140493",
+    "group":"",
+    "keywords": ["youtube", "video", "users", "installs"],
+    "tags": [],
+    "image":"images/cards/card-youtube_2x.png",
+    "lang":"en",
+    "type":"distribute"
+  },
+    {
+    "title":"What is YouTube account good standing?",
+    "titleFriendly":"",
+    "summary":"Learn what it means for an account to be in good standing from the YouTube Help Center.",
+    "url":"https://support.google.com/youtube/answer/2797387",
+    "group":"",
+    "keywords": ["youtube", "video", "users", "installs"],
+    "tags": [],
+    "image":"images/cards/card-youtube_2x.png",
+    "lang":"en",
+    "type":"distribute"
+  },
+
+
+  {
     "lang": "ja",
     "title": "Gaming Everywhere",
     "titleFriendly": "",
diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd
index b207e35..5ab4b89 100644
--- a/docs/html/preview/api-overview.jd
+++ b/docs/html/preview/api-overview.jd
@@ -1,6 +1,7 @@
 page.title=API Overview
 page.keywords=preview,sdk,compatibility
-sdk.platform.apiLevel=23
+sdk.platform.apiLevel=22-mnc
+page.image=images/cards/card-key-changes_16-9_2x.png
 @jd:body
 
 
diff --git a/docs/html/preview/index.jd b/docs/html/preview/index.jd
index c6c2068..2801c18 100644
--- a/docs/html/preview/index.jd
+++ b/docs/html/preview/index.jd
@@ -46,7 +46,38 @@
       <div class="resource-widget resource-flow-layout col-16"
            data-query="collection:preview/landing/resources"
            data-cardSizes="6x2"
-           data-maxResults="6"></div>
+           data-maxResults="3"></div>
     </div>
   </div>
-</section>
\ No newline at end of file
+</section>
+<div class="wrap dac-offset-parent">
+  <a class="dac-fab dac-scroll-button" data-scroll-button href="#latest">
+    <i class="dac-sprite dac-arrow-down-gray"></i>
+  </a>
+</div>
+<section class="dac-section dac-gray dac-small dac-invert" id="latest"><div class="wrap">
+  <h2 class="norule">Latest</h2>
+  <div class="resource-widget resource-flow-layout col-16"
+       data-query="type:blog+tag:featured+tag:preview"
+       data-cardSizes="6x6"
+       data-maxResults="3"></div>
+</div></section>
+
+<section class="dac-section dac-light"><div class="wrap">
+  <h1 class="dac-section-title">Android Data Binding</h1>
+  <div class="dac-section-subtitle">
+    A new way to manage your app's UI. 
+  </div>
+
+  <ul class="dac-section-links">
+    <li class="dac-section-link"><a href="">
+      <span class="dac-sprite dac-auto-chevron"></span>
+      Overview and Usage
+    </a></li>
+    <li class="dac-section-link"><a href="/google/play/filters.html">
+      <span class="dac-sprite dac-auto-chevron"></span>
+      User Guide
+    </a></li>
+
+  </ul>
+</div></section>
\ No newline at end of file
diff --git a/docs/html/preview/overview.jd b/docs/html/preview/overview.jd
index 0c8931d..2c79eba 100644
--- a/docs/html/preview/overview.jd
+++ b/docs/html/preview/overview.jd
@@ -1,4 +1,5 @@
 page.title=Preview Program Overview
+page.image=images/cards/card-preview_16-9_2x.png
 
 @jd:body
 
diff --git a/docs/html/preview/setup-sdk.jd b/docs/html/preview/setup-sdk.jd
index 35fab1a..0d6c498 100644
--- a/docs/html/preview/setup-sdk.jd
+++ b/docs/html/preview/setup-sdk.jd
@@ -1,4 +1,5 @@
-page.title=Setting Up the Preview SDK
+page.title=Set Up the Preview SDK
+page.image=images/cards/card-set-up_16-9_2x.png
 @jd:body
 
 
diff --git a/docs/html/preview/support.jd b/docs/html/preview/support.jd
index 4be6dd7..3ed1487 100644
--- a/docs/html/preview/support.jd
+++ b/docs/html/preview/support.jd
@@ -1,4 +1,5 @@
 page.title=Support
+page.image=images/cards/card-support_16-9_2x.png
 
 @jd:body
 
