diff --git a/res/drawable/padded_rounded_action_button.xml b/res/drawable/padded_rounded_action_button.xml
new file mode 100644
index 0000000..900f5fc
--- /dev/null
+++ b/res/drawable/padded_rounded_action_button.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2021 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android">
+    <item android:bottom="8dp" android:top="8dp">
+        <shape android:shape="rectangle">
+
+        <corners android:radius="@dimen/rounded_button_radius" />
+        <stroke android:width="1dp" android:color="?androidprv:attr/colorAccentPrimaryVariant" />
+        <padding
+            android:left="@dimen/rounded_button_padding"
+            android:right="@dimen/rounded_button_padding" />
+        </shape>
+    </item>
+</layer-list>
+
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 2a2cf89..4735983 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -128,6 +128,8 @@
     <dimen name="work_profile_footer_text_size">16sp</dimen>
     <dimen name="work_edu_card_margin">16dp</dimen>
 
+    <!-- rounded button shown inside card views, and snack bars  -->
+    <dimen name="padded_rounded_button_height">48dp</dimen>
     <dimen name="rounded_button_height">32dp</dimen>
     <dimen name="rounded_button_radius">16dp</dimen>
     <dimen name="rounded_button_padding">8dp</dimen>
