diff --git a/src/msgbuf/platform.h b/src/msgbuf/platform.h
new file mode 100644
index 0000000..c10dc45
--- /dev/null
+++ b/src/msgbuf/platform.h
@@ -0,0 +1,76 @@
+#ifndef PLDM_MSGBUF_PLATFORM_H
+#define PLDM_MSGBUF_PLATFORM_H
+
+#include "../msgbuf.h"
+#include <libpldm/base.h>
+#include <libpldm/platform.h>
+
+static inline int
+pldm_msgbuf_extract_value_pdr_hdr(struct pldm_msgbuf *ctx,
+				  struct pldm_value_pdr_hdr *hdr)
+{
+	pldm_msgbuf_extract(ctx, &hdr->record_handle);
+	pldm_msgbuf_extract(ctx, &hdr->version);
+	pldm_msgbuf_extract(ctx, &hdr->type);
+	pldm_msgbuf_extract(ctx, &hdr->record_change_num);
+	pldm_msgbuf_extract(ctx, &hdr->length);
+
+	return pldm_msgbuf_validate(ctx);
+}
+
+/*
+ * We use __attribute__((always_inline)) below so the compiler has visibility of
+ * the switch() at the call site. It is often the case that the size of multiple
+ * fields depends on the tag. Inlining thus gives the compiler visibility to
+ * hoist one tag-based code-path condition to cover all invocations.
+ */
+
+__attribute__((always_inline)) static inline int
+pldm_msgbuf_extract_sensor_data(struct pldm_msgbuf *ctx,
+				enum pldm_sensor_readings_data_type tag,
+				union_sensor_data_size *dst)
+{
+	switch (tag) {
+	case PLDM_SENSOR_DATA_SIZE_UINT8:
+		return pldm_msgbuf_extract(ctx, &dst->value_u8);
+	case PLDM_SENSOR_DATA_SIZE_SINT8:
+		return pldm_msgbuf_extract(ctx, &dst->value_s8);
+	case PLDM_SENSOR_DATA_SIZE_UINT16:
+		return pldm_msgbuf_extract(ctx, &dst->value_u16);
+	case PLDM_SENSOR_DATA_SIZE_SINT16:
+		return pldm_msgbuf_extract(ctx, &dst->value_s16);
+	case PLDM_SENSOR_DATA_SIZE_UINT32:
+		return pldm_msgbuf_extract(ctx, &dst->value_u32);
+	case PLDM_SENSOR_DATA_SIZE_SINT32:
+		return pldm_msgbuf_extract(ctx, &dst->value_s32);
+	}
+
+	return -PLDM_ERROR_INVALID_DATA;
+}
+
+__attribute__((always_inline)) static inline int
+pldm_msgbuf_extract_range_field_format(struct pldm_msgbuf *ctx,
+				       enum pldm_range_field_format tag,
+				       union_range_field_format *dst)
+{
+	switch (tag) {
+	case PLDM_RANGE_FIELD_FORMAT_UINT8:
+		return pldm_msgbuf_extract(ctx, &dst->value_u8);
+	case PLDM_RANGE_FIELD_FORMAT_SINT8:
+		return pldm_msgbuf_extract(ctx, &dst->value_s8);
+	case PLDM_RANGE_FIELD_FORMAT_UINT16:
+		return pldm_msgbuf_extract(ctx, &dst->value_u16);
+	case PLDM_RANGE_FIELD_FORMAT_SINT16:
+		return pldm_msgbuf_extract(ctx, &dst->value_s16);
+	case PLDM_RANGE_FIELD_FORMAT_UINT32:
+		return pldm_msgbuf_extract(ctx, &dst->value_u32);
+	case PLDM_RANGE_FIELD_FORMAT_SINT32:
+		return pldm_msgbuf_extract(ctx, &dst->value_s32);
+	case PLDM_RANGE_FIELD_FORMAT_REAL32:
+		return pldm_msgbuf_extract(ctx, &dst->value_f32);
+	}
+
+	return -PLDM_ERROR_INVALID_DATA;
+}
+
+#endif
diff --git a/src/platform.c b/src/platform.c
index a805416..0abd6e8 100644
--- a/src/platform.c
+++ b/src/platform.c
@@ -1,10 +1,25 @@
+#include "msgbuf/platform.h"
 #include "base.h"
+#include "msgbuf.h"
+#include "platform.h"
 #include "pldm_types.h"
 #include <endian.h>
 #include <stdint.h>
 #include <string.h>
 
-#include "platform.h"
+static int pldm_platform_pdr_hdr_validate(struct pldm_value_pdr_hdr *ctx,
+					  size_t lower, size_t upper)
+{
+	if (ctx->length + sizeof(*ctx) < lower) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	if (ctx->length > upper) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	return PLDM_SUCCESS;
+}
 
 int encode_state_effecter_pdr(
     struct pldm_state_effecter_pdr *const effecter,
@@ -1235,6 +1250,107 @@
 	return PLDM_SUCCESS;
 }
 
+#define PLDM_NUMERIC_SENSOR_VALUE_PDR_MIN_SIZE 69
+int decode_numeric_sensor_pdr_data(
+    const void *pdr_data, size_t pdr_data_length,
+    struct pldm_numeric_sensor_value_pdr *pdr_value)
+{
+	struct pldm_msgbuf _buf;
+	struct pldm_msgbuf *buf = &_buf;
+	int rc;
+
+	rc = pldm_msgbuf_init(buf, PLDM_NUMERIC_SENSOR_VALUE_PDR_MIN_SIZE,
+			      pdr_data, pdr_data_length);
+	if (rc) {
+		return rc;
+	}
+
+	rc = pldm_msgbuf_extract_value_pdr_hdr(buf, &pdr_value->hdr);
+	if (rc) {
+		return rc;
+	}
+
+	rc = pldm_platform_pdr_hdr_validate(
+	    &pdr_value->hdr, PLDM_NUMERIC_SENSOR_VALUE_PDR_MIN_SIZE,
+	    pdr_data_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_extract(buf, &pdr_value->terminus_handle);
+	pldm_msgbuf_extract(buf, &pdr_value->sensor_id);
+	pldm_msgbuf_extract(buf, &pdr_value->entity_type);
+	pldm_msgbuf_extract(buf, &pdr_value->entity_instance_num);
+	pldm_msgbuf_extract(buf, &pdr_value->container_id);
+	pldm_msgbuf_extract(buf, &pdr_value->sensor_init);
+	pldm_msgbuf_extract(buf, &pdr_value->sensor_auxiliary_names_pdr);
+	pldm_msgbuf_extract(buf, &pdr_value->base_unit);
+	pldm_msgbuf_extract(buf, &pdr_value->unit_modifier);
+	pldm_msgbuf_extract(buf, &pdr_value->rate_unit);
+	pldm_msgbuf_extract(buf, &pdr_value->base_oem_unit_handle);
+	pldm_msgbuf_extract(buf, &pdr_value->aux_unit);
+	pldm_msgbuf_extract(buf, &pdr_value->aux_unit_modifier);
+	pldm_msgbuf_extract(buf, &pdr_value->aux_rate_unit);
+	pldm_msgbuf_extract(buf, &pdr_value->rel);
+	pldm_msgbuf_extract(buf, &pdr_value->aux_oem_unit_handle);
+	pldm_msgbuf_extract(buf, &pdr_value->is_linear);
+
+	rc = pldm_msgbuf_extract(buf, &pdr_value->sensor_data_size);
+	if (rc) {
+		return rc;
+	}
+	if (pdr_value->sensor_data_size > PLDM_SENSOR_DATA_SIZE_MAX) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	pldm_msgbuf_extract(buf, &pdr_value->resolution);
+	pldm_msgbuf_extract(buf, &pdr_value->offset);
+	pldm_msgbuf_extract(buf, &pdr_value->accuracy);
+	pldm_msgbuf_extract(buf, &pdr_value->plus_tolerance);
+	pldm_msgbuf_extract(buf, &pdr_value->minus_tolerance);
+	pldm_msgbuf_extract_sensor_data(buf, pdr_value->sensor_data_size,
+					&pdr_value->hysteresis);
+	pldm_msgbuf_extract(buf, &pdr_value->supported_thresholds.byte);
+	pldm_msgbuf_extract(
+	    buf, &pdr_value->threshold_and_hysteresis_volatility.byte);
+	pldm_msgbuf_extract(buf, &pdr_value->state_transition_interval);
+	pldm_msgbuf_extract(buf, &pdr_value->update_interval);
+	pldm_msgbuf_extract_sensor_data(buf, pdr_value->sensor_data_size,
+					&pdr_value->max_readable);
+	pldm_msgbuf_extract_sensor_data(buf, pdr_value->sensor_data_size,
+					&pdr_value->min_readable);
+
+	rc = pldm_msgbuf_extract(buf, &pdr_value->range_field_format);
+	if (rc) {
+		return rc;
+	}
+	if (pdr_value->range_field_format > PLDM_RANGE_FIELD_FORMAT_MAX) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	pldm_msgbuf_extract(buf, &pdr_value->range_field_support.byte);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->nominal_value);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->normal_max);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->normal_min);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->warning_high);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->warning_low);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->critical_high);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->critical_low);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->fatal_high);
+	pldm_msgbuf_extract_range_field_format(
+	    buf, pdr_value->range_field_format, &pdr_value->fatal_low);
+
+	return pldm_msgbuf_destroy(buf);
+}
+
 int encode_get_numeric_effecter_value_req(uint8_t instance_id,
 					  uint16_t effecter_id,
 					  struct pldm_msg *msg)