diff --git a/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.java b/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.java
index 4d633aae998..cbcaf8169a4 100644
--- a/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.java
+++ b/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.java
@@ -25,17 +25,32 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
     ReadableMapBufferSoLoader.staticInit();
   }
 
+  /**
+   * Data types supported by MapBuffer. Keep in sync with definition in `MapBuffer.h`, as enum
+   * serialization relies on correct order.
+   */
+  public enum DataType {
+    BOOL,
+    INT,
+    DOUBLE,
+    STRING,
+    MAP;
+  }
+
   // Value used to verify if the data is serialized with LittleEndian order.
   private static final int ALIGNMENT = 0xFE;
 
   // 8 bytes = 2 (alignment) + 2 (count) + 4 (size)
   private static final int HEADER_SIZE = 8;
 
-  // key size = 2 bytes
-  private static final int KEY_SIZE = 2;
+  // 10 bytes = 2 (key) + 2 (type) + 8 (value)
+  private static final int BUCKET_SIZE = 12;
 
-  // 10 bytes = 2 bytes key + 8 bytes value
-  private static final int BUCKET_SIZE = 10;
+  // 2 bytes = 2 (key)
+  private static final int TYPE_OFFSET = 2;
+
+  // 4 bytes = 2 (key) + 2 (type)
+  private static final int VALUE_OFFSET = 4;
 
   private static final int INT_SIZE = 4;
 
@@ -65,17 +80,6 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
     return HEADER_SIZE + BUCKET_SIZE * bucketIndex;
   }
 
-  private int getValueOffsetForKey(int key) {
-    importByteBufferAndReadHeader();
-    int bucketIndex = getBucketIndexForKey(key);
-    if (bucketIndex == -1) {
-      // TODO T83483191: Add tests
-      throw new IllegalArgumentException("Unable to find key: " + key);
-    }
-    assertKeyExists(key, bucketIndex);
-    return getKeyOffsetForBucketIndex(bucketIndex) + KEY_SIZE;
-  }
-
   // returns the relative offset of the first byte of dynamic data
   private int getOffsetForDynamicData() {
     // TODO T83483191: check if there's dynamic data?
@@ -88,6 +92,7 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
    *     (log(n))
    */
   private int getBucketIndexForKey(int key) {
+    importByteBufferAndReadHeader();
     int lo = 0;
     int hi = getCount() - 1;
     while (lo <= hi) {
@@ -104,8 +109,34 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
     return -1;
   }
 
-  private int readUnsignedShort(int position) {
-    return mBuffer.getShort(position) & 0xFFFF;
+  private DataType readDataType(int bucketIndex) {
+    int value = readUnsignedShort(getKeyOffsetForBucketIndex(bucketIndex) + TYPE_OFFSET);
+    return DataType.values()[value];
+  }
+
+  private int getTypedValueOffsetForKey(int key, DataType expected) {
+    int bucketIndex = getBucketIndexForKey(key);
+    DataType dataType = readDataType(bucketIndex);
+    if (bucketIndex == -1) {
+      throw new IllegalArgumentException("Key not found: " + key);
+    }
+
+    if (dataType != expected) {
+      throw new IllegalStateException(
+          "Expected "
+              + expected
+              + " for key: "
+              + key
+              + " found "
+              + dataType.toString()
+              + " instead.");
+    }
+
+    return getKeyOffsetForBucketIndex(bucketIndex) + VALUE_OFFSET;
+  }
+
+  private int readUnsignedShort(int bufferPosition) {
+    return mBuffer.getShort(bufferPosition) & 0xFFFF;
   }
 
   private double readDoubleValue(int bufferPosition) {
@@ -169,6 +200,17 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
     return getBucketIndexForKey(key) != -1;
   }
 
+  @Nullable
+  public DataType getType(int key) {
+    int bucketIndex = getBucketIndexForKey(key);
+
+    if (bucketIndex == -1) {
+      throw new IllegalArgumentException("Key not found: " + key);
+    }
+
+    return readDataType(bucketIndex);
+  }
+
   /** @return amount of elements stored into the MapBuffer */
   public int getCount() {
     importByteBufferAndReadHeader();
@@ -180,8 +222,7 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
    * @return return the int associated to the Key received as a parameter.
    */
   public int getInt(int key) {
-    // TODO T83483191: extract common code of "get methods"
-    return readIntValue(getValueOffsetForKey(key));
+    return readIntValue(getTypedValueOffsetForKey(key, DataType.INT));
   }
 
   /**
@@ -189,7 +230,7 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
    * @return return the double associated to the Key received as a parameter.
    */
   public double getDouble(int key) {
-    return readDoubleValue(getValueOffsetForKey(key));
+    return readDoubleValue(getTypedValueOffsetForKey(key, DataType.DOUBLE));
   }
 
   /**
@@ -197,11 +238,11 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
    * @return return the int associated to the Key received as a parameter.
    */
   public String getString(int key) {
-    return readStringValue(getValueOffsetForKey(key));
+    return readStringValue(getTypedValueOffsetForKey(key, DataType.STRING));
   }
 
   public boolean getBoolean(int key) {
-    return readBooleanValue(getValueOffsetForKey(key));
+    return readBooleanValue(getTypedValueOffsetForKey(key, DataType.BOOL));
   }
 
   /**
@@ -209,7 +250,7 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
    * @return return the int associated to the Key received as a parameter.
    */
   public ReadableMapBuffer getMapBuffer(int key) {
-    return readMapBufferValue(getValueOffsetForKey(key));
+    return readMapBufferValue(getTypedValueOffsetForKey(key, DataType.MAP));
   }
 
   /**
@@ -287,39 +328,61 @@ public class ReadableMapBuffer implements Iterable<ReadableMapBuffer.MapBufferEn
       mBucketOffset = position;
     }
 
+    private void assertType(DataType expected) {
+      DataType dataType = getType();
+      if (expected != dataType) {
+        throw new IllegalStateException(
+            "Expected "
+                + expected
+                + " for key: "
+                + getKey()
+                + " found "
+                + dataType.toString()
+                + " instead.");
+      }
+    }
+
     /** @return a {@link short} that represents the key of this {@link MapBufferEntry}. */
     public int getKey() {
       return readUnsignedShort(mBucketOffset);
     }
 
+    public DataType getType() {
+      return DataType.values()[readUnsignedShort(mBucketOffset + TYPE_OFFSET)];
+    }
+
     /** @return the double value that is stored in this {@link MapBufferEntry}. */
-    public double getDouble(double defaultValue) {
-      // TODO T83483191 Extend serialization of MapBuffer to add type checking
+    public double getDouble() {
       // TODO T83483191 Extend serialization of MapBuffer to return null if there's no value
       // stored in this MapBufferEntry.
-      return readDoubleValue(mBucketOffset + KEY_SIZE);
+      assertType(DataType.DOUBLE);
+      return readDoubleValue(mBucketOffset + VALUE_OFFSET);
     }
 
     /** @return the int value that is stored in this {@link MapBufferEntry}. */
-    public int getInt(int defaultValue) {
-      return readIntValue(mBucketOffset + KEY_SIZE);
+    public int getInt() {
+      assertType(DataType.INT);
+      return readIntValue(mBucketOffset + VALUE_OFFSET);
     }
 
     /** @return the boolean value that is stored in this {@link MapBufferEntry}. */
-    public boolean getBoolean(boolean defaultValue) {
-      return readBooleanValue(mBucketOffset + KEY_SIZE);
+    public boolean getBoolean() {
+      assertType(DataType.BOOL);
+      return readBooleanValue(mBucketOffset + VALUE_OFFSET);
     }
 
     /** @return the String value that is stored in this {@link MapBufferEntry}. */
     public @Nullable String getString() {
-      return readStringValue(mBucketOffset + KEY_SIZE);
+      assertType(DataType.STRING);
+      return readStringValue(mBucketOffset + VALUE_OFFSET);
     }
 
     /**
      * @return the {@link ReadableMapBuffer} value that is stored in this {@link MapBufferEntry}.
      */
     public @Nullable ReadableMapBuffer getReadableMapBuffer() {
-      return readMapBufferValue(mBucketOffset + KEY_SIZE);
+      assertType(DataType.MAP);
+      return readMapBufferValue(mBucketOffset + VALUE_OFFSET);
     }
   }
 }
diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java b/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java
index 1de0b2ca56e..e2e717b2b51 100644
--- a/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java
+++ b/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java
@@ -149,10 +149,10 @@ public class TextAttributeProps {
       ReadableMapBuffer.MapBufferEntry entry = iterator.next();
       switch (entry.getKey()) {
         case TA_KEY_FOREGROUND_COLOR:
-          result.setColor(entry.getInt(0));
+          result.setColor(entry.getInt());
           break;
         case TA_KEY_BACKGROUND_COLOR:
-          result.setBackgroundColor(entry.getInt(0));
+          result.setBackgroundColor(entry.getInt());
           break;
         case TA_KEY_OPACITY:
           break;
@@ -160,7 +160,7 @@ public class TextAttributeProps {
           result.setFontFamily(entry.getString());
           break;
         case TA_KEY_FONT_SIZE:
-          result.setFontSize((float) entry.getDouble(UNSET));
+          result.setFontSize((float) entry.getDouble());
           break;
         case TA_KEY_FONT_SIZE_MULTIPLIER:
           break;
@@ -174,13 +174,13 @@ public class TextAttributeProps {
           result.setFontVariant(entry.getReadableMapBuffer());
           break;
         case TA_KEY_ALLOW_FONT_SCALING:
-          result.setAllowFontScaling(entry.getBoolean(true));
+          result.setAllowFontScaling(entry.getBoolean());
           break;
         case TA_KEY_LETTER_SPACING:
-          result.setLetterSpacing((float) entry.getDouble(Float.NaN));
+          result.setLetterSpacing((float) entry.getDouble());
           break;
         case TA_KEY_LINE_HEIGHT:
-          result.setLineHeight((float) entry.getDouble(UNSET));
+          result.setLineHeight((float) entry.getDouble());
           break;
         case TA_KEY_ALIGNMENT:
           break;
@@ -194,10 +194,10 @@ public class TextAttributeProps {
         case TA_KEY_TEXT_DECORATION_STYLE:
           break;
         case TA_KEY_TEXT_SHADOW_RAIDUS:
-          result.setTextShadowRadius(entry.getInt(1));
+          result.setTextShadowRadius(entry.getInt());
           break;
         case TA_KEY_TEXT_SHADOW_COLOR:
-          result.setTextShadowColor(entry.getInt(DEFAULT_TEXT_SHADOW_COLOR));
+          result.setTextShadowColor(entry.getInt());
           break;
         case TA_KEY_IS_HIGHLIGHTED:
           break;
diff --git a/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp b/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp
index 74b55070227..c6123f08d81 100644
--- a/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp
+++ b/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp
@@ -72,7 +72,6 @@ double MapBuffer::getDouble(Key key) const {
 
   return *reinterpret_cast<double const *>(
       bytes_.data() + valueOffset(bucketIndex));
-  ;
 }
 
 int32_t MapBuffer::getDynamicDataOffset() const {
@@ -113,10 +112,6 @@ MapBuffer MapBuffer::getMapBuffer(Key key) const {
   return MapBuffer(std::move(value));
 }
 
-bool MapBuffer::isNull(Key key) const {
-  return getInt(key) == NULL_VALUE;
-}
-
 uint32_t MapBuffer::size() const {
   return bytes_.size();
 }
diff --git a/ReactCommon/react/renderer/mapbuffer/MapBuffer.h b/ReactCommon/react/renderer/mapbuffer/MapBuffer.h
index 2afcee04251..45e415c0a23 100644
--- a/ReactCommon/react/renderer/mapbuffer/MapBuffer.h
+++ b/ReactCommon/react/renderer/mapbuffer/MapBuffer.h
@@ -18,11 +18,11 @@ namespace react {
 class ReadableMapBuffer;
 
 /**
- * MapBuffer is an optimized map format for transferring data like props between
- * C++ and other platforms The implementation of this map is optimized to:
+ * MapBuffer is an optimized sparse array format for transferring props-like
+ * between C++ and other VMs. The implementation of this map is optimized to:
  * - be compact to optimize space when sparse (sparse is the common case).
  * - be accessible through JNI with zero/minimal copying via ByteBuffer.
- * - be Have excellent C++ single-write and many-read performance by maximizing
+ * - Have excellent C++ single-write and many-read performance by maximizing
  *   CPU cache performance through compactness, data locality, and fixed offsets
  *   where possible.
  * - be optimized for iteration and intersection against other maps, but with
@@ -33,21 +33,20 @@ class ReadableMapBuffer;
  * - have minimal APK size and build time impact.
  */
 class MapBuffer {
-  friend ReadableMapBuffer;
-
- private:
-  // Buffer and its size
-  std::vector<uint8_t> const bytes_;
-
-  // amount of items in the MapBuffer
-  uint16_t count_ = 0;
-
-  // returns the relative offset of the first byte of dynamic data
-  int32_t getDynamicDataOffset() const;
-
-  uint32_t getKeyBucket(Key key) const;
-
  public:
+  /**
+   * Data types available for serialization in MapBuffer
+   * Keep in sync with `DataType` enum in `ReadableMapBuffer.java`, which
+   * expects the same values after reading them through JNI.
+   */
+  enum DataType : uint16_t {
+    Boolean = 0,
+    Int = 1,
+    Double = 2,
+    String = 3,
+    Map = 4,
+  };
+
   explicit MapBuffer(std::vector<uint8_t> data);
 
   MapBuffer(MapBuffer const &buffer) = delete;
@@ -67,13 +66,25 @@ class MapBuffer {
   // TODO T83483191: review this declaration
   MapBuffer getMapBuffer(Key key) const;
 
-  bool isNull(Key key) const;
-
   uint32_t size() const;
 
   uint8_t const *data() const;
 
   uint16_t count() const;
+
+ private:
+  // Buffer and its size
+  std::vector<uint8_t> const bytes_;
+
+  // amount of items in the MapBuffer
+  uint16_t count_ = 0;
+
+  // returns the relative offset of the first byte of dynamic data
+  int32_t getDynamicDataOffset() const;
+
+  uint32_t getKeyBucket(Key key) const;
+
+  friend ReadableMapBuffer;
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp b/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp
index 89de1e34128..8438686bc87 100644
--- a/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp
+++ b/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp
@@ -23,7 +23,8 @@ MapBufferBuilder::MapBufferBuilder(uint32_t initialSize) {
 
 void MapBufferBuilder::storeKeyValue(
     Key key,
-    uint8_t const *value,
+    MapBuffer::DataType type,
+    Byte const *value,
     uint32_t valueSize) {
   if (valueSize > MAX_VALUE_SIZE) {
     LOG(ERROR) << "Error: size of value must be <= MAX_VALUE_SIZE. ValueSize: "
@@ -35,7 +36,7 @@ void MapBufferBuilder::storeKeyValue(
   auto *dataPtr = reinterpret_cast<uint8_t *>(&data);
   memcpy(dataPtr, value, valueSize);
 
-  buckets_.emplace_back(key, data);
+  buckets_.emplace_back(key, static_cast<uint16_t>(type), data);
 
   header_.count++;
 
@@ -46,21 +47,28 @@ void MapBufferBuilder::storeKeyValue(
 }
 
 void MapBufferBuilder::putBool(Key key, bool value) {
-  putInt(key, (int)value);
+  int intValue = (int)value;
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Boolean,
+      reinterpret_cast<uint8_t const *>(&intValue),
+      INT_SIZE);
 }
 
 void MapBufferBuilder::putDouble(Key key, double value) {
-  auto const *bytePointer = reinterpret_cast<uint8_t *>(&value);
-  storeKeyValue(key, bytePointer, DOUBLE_SIZE);
-}
-
-void MapBufferBuilder::putNull(Key key) {
-  putInt(key, NULL_VALUE);
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Double,
+      reinterpret_cast<uint8_t const *>(&value),
+      DOUBLE_SIZE);
 }
 
 void MapBufferBuilder::putInt(Key key, int32_t value) {
-  auto const *bytePointer = reinterpret_cast<uint8_t *>(&(value));
-  storeKeyValue(key, bytePointer, INT_SIZE);
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Int,
+      reinterpret_cast<uint8_t const *>(&value),
+      INT_SIZE);
 }
 
 void MapBufferBuilder::putString(Key key, std::string const &value) {
@@ -74,7 +82,11 @@ void MapBufferBuilder::putString(Key key, std::string const &value) {
   memcpy(dynamicData_.data() + offset + INT_SIZE, strData, strSize);
 
   // Store Key and pointer to the string
-  putInt(key, offset);
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::String,
+      reinterpret_cast<uint8_t const *>(&offset),
+      INT_SIZE);
 }
 
 void MapBufferBuilder::putMapBuffer(Key key, MapBuffer const &map) {
@@ -89,7 +101,11 @@ void MapBufferBuilder::putMapBuffer(Key key, MapBuffer const &map) {
   memcpy(dynamicData_.data() + offset + INT_SIZE, map.data(), mapBufferSize);
 
   // Store Key and pointer to the string
-  putInt(key, offset);
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Map,
+      reinterpret_cast<uint8_t const *>(&offset),
+      INT_SIZE);
 }
 
 static inline bool compareBuckets(Bucket const &a, Bucket const &b) {
diff --git a/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h b/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h
index df40992aeb1..27a48d2bf81 100644
--- a/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h
+++ b/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h
@@ -16,7 +16,7 @@ namespace facebook {
 namespace react {
 
 // Default reserved size for buckets_ vector
-constexpr uint16_t INITIAL_BUCKETS_SIZE = 10;
+constexpr uint32_t INITIAL_BUCKETS_SIZE = 10;
 
 /**
  * MapBufferBuilder is a builder class for MapBuffer
@@ -33,8 +33,6 @@ class MapBufferBuilder {
 
   void putDouble(Key key, double value);
 
-  void putNull(Key key);
-
   void putString(Key key, std::string const &value);
 
   void putMapBuffer(Key key, MapBuffer const &map);
@@ -52,7 +50,11 @@ class MapBufferBuilder {
 
   bool needsSort_{false};
 
-  void storeKeyValue(Key key, uint8_t const *value, uint32_t valueSize);
+  void storeKeyValue(
+      Key key,
+      MapBuffer::DataType type,
+      Byte const *value,
+      uint32_t valueSize);
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/mapbuffer/primitives.h b/ReactCommon/react/renderer/mapbuffer/primitives.h
index f5722a820f9..58d4b2012d3 100644
--- a/ReactCommon/react/renderer/mapbuffer/primitives.h
+++ b/ReactCommon/react/renderer/mapbuffer/primitives.h
@@ -34,12 +34,14 @@ static_assert(sizeof(Header) == 8, "MapBuffer header size is incorrect.");
 
 struct __attribute__((__packed__)) Bucket {
   Key key;
+  uint16_t type;
   uint64_t data;
 
-  Bucket(Key key, uint64_t data) : key(key), data(data){};
+  Bucket(Key key, uint16_t type, uint64_t data)
+      : key(key), type(type), data(data) {}
 };
 
-static_assert(sizeof(Bucket) == 10, "MapBuffer bucket size is incorrect.");
+static_assert(sizeof(Bucket) == 12, "MapBuffer bucket size is incorrect.");
 
 constexpr static int32_t KEY_SIZE = sizeof(Key);
 constexpr static int32_t HEADER_SIZE = sizeof(Header);
@@ -55,7 +57,6 @@ constexpr static int32_t HEADER_BUFFER_SIZE_OFFSET =
 
 constexpr static int32_t MAX_VALUE_SIZE = UINT64_SIZE;
 
-// 10 bytes : 2 key + 8 value
 constexpr static int32_t BUCKET_SIZE = sizeof(Bucket);
 
 inline void
diff --git a/ReactCommon/react/renderer/mapbuffer/tests/MapBufferTest.cpp b/ReactCommon/react/renderer/mapbuffer/tests/MapBufferTest.cpp
index 886c86d9c60..f0d5c737541 100644
--- a/ReactCommon/react/renderer/mapbuffer/tests/MapBufferTest.cpp
+++ b/ReactCommon/react/renderer/mapbuffer/tests/MapBufferTest.cpp
@@ -59,23 +59,6 @@ TEST(MapBufferTest, testBoolEntries) {
   EXPECT_EQ(map.getBool(1), false);
 }
 
-TEST(MapBufferTest, testNullEntries) {
-  auto buffer = MapBufferBuilder();
-
-  buffer.putNull(0);
-  buffer.putInt(1, 1234);
-
-  auto map = buffer.build();
-
-  EXPECT_EQ(map.count(), 2);
-  EXPECT_EQ(map.isNull(0), true);
-  EXPECT_EQ(map.isNull(1), false);
-  // TODO T83483191: serialize null values to be distinguishable from '0'
-  // values
-  // EXPECT_EQ(map.isNull(1),  false);
-  // EXPECT_EQ(map.getBool(1),  false);
-}
-
 TEST(MapBufferTest, testDoubleEntries) {
   auto buffer = MapBufferBuilder();
 
@@ -172,14 +155,12 @@ TEST(MapBufferTest, testMapRandomAccess) {
   builder.putInt(1234, 4321);
   builder.putString(0, "This is a test");
   builder.putDouble(8, 908.1);
-  builder.putNull(2);
   builder.putString(65535, "Let's count: 的, 一, 是");
   auto map = builder.build();
 
-  EXPECT_EQ(map.count(), 5);
+  EXPECT_EQ(map.count(), 4);
   EXPECT_EQ(map.getString(0), "This is a test");
   EXPECT_EQ(map.getDouble(8), 908.1);
-  EXPECT_EQ(map.isNull(2), true);
   EXPECT_EQ(map.getInt(1234), 4321);
   EXPECT_EQ(map.getString(65535), "Let's count: 的, 一, 是");
 }