diff --git a/gddo-server/assets/site.css b/gddo-server/assets/site.css
index 2c63f38..b3d9afd 100644
--- a/gddo-server/assets/site.css
+++ b/gddo-server/assets/site.css
@@ -121,7 +121,7 @@
 
 .banner {
     align-items: center;
-    background-color: #fffbe0;
+    background-color: #fedc00;
     display: flex;
     justify-content: space-between;
     margin-bottom: 20px;
diff --git a/gddo-server/assets/templates/layout.html b/gddo-server/assets/templates/layout.html
index d35f4a8..65acc3b 100644
--- a/gddo-server/assets/templates/layout.html
+++ b/gddo-server/assets/templates/layout.html
@@ -35,11 +35,10 @@
 </nav>
 <div class="banner">
   <div class="banner-message">
-    Pkg.go.dev is a new destination for Go discovery & docs. Check it out at {{template "PkgGoDevLink" $}} and share your feedback.
+    <a href="https://pkg.go.dev">Pkg.go.dev</a> is a new destination for Go discovery & docs. <a class="banner-action" href="https://blog.golang.org/pkg.go.dev-2020">Learn more</a>
   </div>
   <div class="banner-action-container">
-    <a class="banner-action" href="?redirect=on">Always use pkg.go.dev</a>
-    <a class="banner-action" href="https://blog.golang.org/pkg.go.dev-2020">Learn more</a>
+    Save time, set redirect → <a class="banner-action" href="?redirect=on">Always use pkg.go.dev</a>
   </div>
 </div>
 
