diff --git a/java/com/android/dialer/main/impl/MainPagerAdapter.java b/java/com/android/dialer/main/impl/MainPagerAdapter.java
index 10256a1..2d224f6 100644
--- a/java/com/android/dialer/main/impl/MainPagerAdapter.java
+++ b/java/com/android/dialer/main/impl/MainPagerAdapter.java
@@ -23,7 +23,7 @@
 import android.support.v4.app.FragmentStatePagerAdapter;
 import com.android.dialer.calllog.ui.NewCallLogFragment;
 import com.android.dialer.common.Assert;
-import com.android.dialer.voicemail.listui.VoicemailFragment;
+import com.android.dialer.voicemail.listui.NewVoicemailFragment;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
@@ -60,7 +60,7 @@
     // TODO(calderwoodra): implement tabs
     switch (position) {
       case TabIndex.VOICEMAIL:
-        return new VoicemailFragment();
+        return new NewVoicemailFragment();
       case TabIndex.HISTORY:
         return new NewCallLogFragment();
       default:
diff --git a/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogAdapter.java b/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogAdapter.java
new file mode 100644
index 0000000..63dae20
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogAdapter.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2017 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
+ */
+package com.android.dialer.voicemail.listui;
+
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import com.android.dialer.common.LogUtil;
+import java.util.List;
+
+/** {@link RecyclerView.Adapter} for the new voicemail call log fragment. */
+final class NewVoicemailCallLogAdapter extends RecyclerView.Adapter<NewVoicemailCallLogViewHolder> {
+
+  private final List<String> values;
+
+  NewVoicemailCallLogAdapter(List<String> myDataset) {
+    values = myDataset;
+  }
+
+  @Override
+  public NewVoicemailCallLogViewHolder onCreateViewHolder(ViewGroup viewGroup, int viewType) {
+
+    LayoutInflater inflater = LayoutInflater.from(viewGroup.getContext());
+    View v = inflater.inflate(R.layout.voicemail_call_log_entry, viewGroup, false);
+
+    NewVoicemailCallLogViewHolder newVoicemailCallLogViewHolder =
+        new NewVoicemailCallLogViewHolder(v);
+    return newVoicemailCallLogViewHolder;
+  }
+
+  @Override
+  public void onBindViewHolder(NewVoicemailCallLogViewHolder viewHolder, int position) {
+    LogUtil.i("onBindViewHolder", "position" + position);
+    String name = values.get(position);
+    viewHolder.setPrimaryText(name);
+  }
+
+  @Override
+  public int getItemCount() {
+    return values.size();
+  }
+}
diff --git a/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogViewHolder.java b/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogViewHolder.java
new file mode 100644
index 0000000..239c946
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/NewVoicemailCallLogViewHolder.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 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
+ */
+package com.android.dialer.voicemail.listui;
+
+import android.support.v7.widget.RecyclerView;
+import android.view.View;
+import android.widget.TextView;
+
+/** {@link RecyclerView.ViewHolder} for the new voicemail call log. */
+final class NewVoicemailCallLogViewHolder extends RecyclerView.ViewHolder {
+
+  private final TextView primaryTextView;
+
+  NewVoicemailCallLogViewHolder(View view) {
+    super(view);
+    primaryTextView = (TextView) view.findViewById(R.id.primary_text);
+  }
+
+  public void setPrimaryText(String name) {
+    this.primaryTextView.setText(name);
+  }
+}
diff --git a/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java
new file mode 100644
index 0000000..cb8cc31
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2017 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
+ */
+
+package com.android.dialer.voicemail.listui;
+
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import com.android.dialer.common.LogUtil;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Fragment for Dialer Voicemail Tab. */
+public final class NewVoicemailFragment extends Fragment {
+  @Nullable
+  @Override
+  public View onCreateView(
+      LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+    View view = inflater.inflate(R.layout.new_voicemail_call_log_fragment, container, false);
+    RecyclerView recyclerView =
+        (RecyclerView) view.findViewById(R.id.new_voicemail_call_log_recycler_view);
+    recyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
+
+    // TODO(uabdullah): To be removed once we hook up the UI to the voicemail backend
+    List<String> input = new ArrayList<>();
+    for (int i = 0; i < 50; i++) {
+      input.add("Umer Abdullah " + i);
+    }
+
+    LogUtil.i("onCreateView", "size of input:" + input.size());
+    recyclerView.setAdapter(new NewVoicemailCallLogAdapter(input));
+    return view;
+  }
+}
diff --git a/java/com/android/dialer/voicemail/listui/VoicemailFragment.java b/java/com/android/dialer/voicemail/listui/VoicemailFragment.java
deleted file mode 100644
index e2b87a8..0000000
--- a/java/com/android/dialer/voicemail/listui/VoicemailFragment.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2017 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
- */
-
-package com.android.dialer.voicemail.listui;
-
-import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-
-/** Fragment for Dialer Voicemail Tab. */
-public final class VoicemailFragment extends Fragment {
-
-  @Nullable
-  @Override
-  public View onCreateView(
-      LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
-    return inflater.inflate(R.layout.voicemail_fragment, container, false);
-  }
-}
diff --git a/java/com/android/dialer/voicemail/listui/res/layout/voicemail_fragment.xml b/java/com/android/dialer/voicemail/listui/res/layout/new_voicemail_call_log_fragment.xml
similarity index 72%
rename from java/com/android/dialer/voicemail/listui/res/layout/voicemail_fragment.xml
rename to java/com/android/dialer/voicemail/listui/res/layout/new_voicemail_call_log_fragment.xml
index 3b566da..f35ce4d 100644
--- a/java/com/android/dialer/voicemail/listui/res/layout/voicemail_fragment.xml
+++ b/java/com/android/dialer/voicemail/listui/res/layout/new_voicemail_call_log_fragment.xml
@@ -14,15 +14,10 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License
   -->
-<FrameLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
 
-  <TextView
-      android:id="@+id/voicemail_fragment_text_view"
-      android:text="@string/welcome_text"
-      android:layout_width="wrap_content"
-      android:layout_height="wrap_content"
-      android:layout_gravity="center"/>
-</FrameLayout>
\ No newline at end of file
+<android.support.v7.widget.RecyclerView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/new_voicemail_call_log_recycler_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/background_dialer_light"/>
\ No newline at end of file
diff --git a/java/com/android/dialer/voicemail/listui/res/layout/voicemail_call_log_entry.xml b/java/com/android/dialer/voicemail/listui/res/layout/voicemail_call_log_entry.xml
new file mode 100644
index 0000000..3986a0e
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/res/layout/voicemail_call_log_entry.xml
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+
+<RelativeLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_marginTop="@dimen/call_log_entry_top_margin"
+    android:paddingTop="@dimen/call_log_entry_padding_top_start"
+    android:paddingBottom="@dimen/call_log_entry_padding_bottom_end"
+    android:paddingStart="@dimen/call_log_entry_padding_top_start"
+    android:paddingEnd="@dimen/call_log_entry_padding_bottom_end"
+    android:gravity="center_vertical">
+
+  <QuickContactBadge
+      android:id="@+id/quick_contact_photo"
+      android:layout_width="@dimen/call_log_entry_photo_size"
+      android:layout_height="@dimen/call_log_entry_photo_size"
+      android:layout_centerVertical="true"
+      android:padding="@dimen/call_log_entry_photo_padding"
+      android:background="@color/dialer_secondary_color"
+      android:focusable="true"/>
+
+  <LinearLayout
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_centerVertical="true"
+      android:layout_toEndOf="@+id/quick_contact_photo"
+      android:layout_toStartOf="@+id/menu_button"
+      android:orientation="vertical">
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal">
+
+      <TextView
+          android:id="@+id/primary_text"
+          style="@style/PrimaryText"
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:layout_marginStart="@dimen/call_log_entry_photo_text_margin"/>
+    </LinearLayout>
+  </LinearLayout>
+
+  <!--TODO(uabdullah): Figure out why android:src="@drawable/quantum_ic_more_vert_vd_theme_24"
+  causes http://gpaste/5400195130982400 -->
+  <ImageView
+      android:id="@+id/menu_button"
+      android:layout_width="@dimen/call_log_entry_menu_button_size"
+      android:layout_height="@dimen/call_log_entry_menu_button_size"
+      android:layout_alignParentEnd="true"
+      android:layout_centerVertical="true"
+      android:background="?android:attr/selectableItemBackgroundBorderless"
+      android:scaleType="center"
+      android:tint="@color/dialer_secondary_text_color"/>
+</RelativeLayout>
diff --git a/java/com/android/dialer/voicemail/listui/res/values/dimens.xml b/java/com/android/dialer/voicemail/listui/res/values/dimens.xml
new file mode 100644
index 0000000..4ef0fc1
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/res/values/dimens.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 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
+  -->
+<resources>
+
+  <!-- TODO(uabdullah): These values are to be shared with the call log entries -->
+  <dimen name="call_log_entry_top_margin">6dp</dimen>
+  <dimen name="call_log_entry_padding_bottom_end">16dp</dimen>
+  <dimen name="call_log_entry_padding_top_start">12dp</dimen>
+  <dimen name="call_log_entry_photo_size">48dp</dimen>
+  <dimen name="call_log_entry_photo_padding">4dp</dimen>
+  <dimen name="call_log_entry_photo_text_margin">8dp</dimen>
+  <dimen name="call_log_entry_menu_button_size">48dp</dimen>
+
+</resources>
diff --git a/java/com/android/dialer/voicemail/listui/res/values/strings.xml b/java/com/android/dialer/voicemail/listui/res/values/strings.xml
deleted file mode 100644
index 85d4190..0000000
--- a/java/com/android/dialer/voicemail/listui/res/values/strings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-<resources>
-  <string name="welcome_text" translatable="false">hello world! Welcome to the Voicemail Tab!</string>
-</resources>
\ No newline at end of file
