diff --git a/src/gpu/GrProgramDesc.cpp b/src/gpu/GrProgramDesc.cpp
index ebb3a7f..c8b266f 100644
--- a/src/gpu/GrProgramDesc.cpp
+++ b/src/gpu/GrProgramDesc.cpp
@@ -175,7 +175,11 @@
     // bindings in use or other descriptor field settings) it should be set
     // to a canonical value to avoid duplicate programs with different keys.
 
+    static_assert(0 == kProcessorKeysOffset % sizeof(uint32_t));
+    // Make room for everything up to the effect keys.
     desc->key().reset();
+    desc->key().push_back_n(kProcessorKeysOffset);
+
     GrProcessorKeyBuilder b(&desc->key());
 
     const GrPrimitiveProcessor& primitiveProcessor = programInfo.primProc();
@@ -219,29 +223,36 @@
         b.add32(renderTarget->getSamplePatternKey());
     }
 
-    // Add "header" metadata
-    uint32_t header = 0;
-    SkDEBUGCODE(uint32_t header_bits = 0);
-    auto add_bits = [&](uint32_t nbits, uint32_t val) {
-        SkASSERT(val < (1 << nbits));
-        SkASSERT((header_bits += nbits) <= 32);
-        header = (header << nbits) | val;
-    };
-    add_bits(16, pipeline.writeSwizzle().asKey());
-    add_bits( 1, numColorFPs);
-    add_bits( 2, numCoverageFPs);
+    // --------DO NOT MOVE HEADER ABOVE THIS LINE--------------------------------------------------
+    // Because header is a pointer into the dynamic array, we can't push any new data into the key
+    // below here.
+    KeyHeader* header = desc->atOffset<KeyHeader, kHeaderOffset>();
+
+    // make sure any padding in the header is zeroed.
+    memset(header, 0, kHeaderSize);
+    header->fWriteSwizzle = pipeline.writeSwizzle().asKey();
+    header->fColorFragmentProcessorCnt = numColorFPs;
+    header->fCoverageFragmentProcessorCnt = numCoverageFPs;
+    SkASSERT(header->fColorFragmentProcessorCnt == numColorFPs);
+    SkASSERT(header->fCoverageFragmentProcessorCnt == numCoverageFPs);
     // If we knew the shader won't depend on origin, we could skip this (and use the same program
     // for both origins). Instrumenting all fragment processors would be difficult and error prone.
-    add_bits( 2, GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(programInfo.origin()));
-    add_bits( 1, static_cast<uint32_t>(programInfo.requestedFeatures()));
-    add_bits( 1, pipeline.snapVerticesToPixelCenters());
+    header->fSurfaceOriginKey =
+                    GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(programInfo.origin());
+    header->fProcessorFeatures = (uint8_t)programInfo.requestedFeatures();
+    // Ensure enough bits.
+    SkASSERT(header->fProcessorFeatures == (int) programInfo.requestedFeatures());
+    header->fSnapVerticesToPixelCenters = pipeline.snapVerticesToPixelCenters();
     // The base descriptor only stores whether or not the primitiveType is kPoints. Backend-
     // specific versions (e.g., Vulkan) require more detail
-    add_bits( 1, (programInfo.primitiveType() == GrPrimitiveType::kPoints));
+    header->fHasPointSize = (programInfo.primitiveType() == GrPrimitiveType::kPoints);
 
-    b.add32(header);
-
-    desc->fInitialKeyLength = desc->keyLength();
+    header->fInitialKeyLength = desc->keyLength();
+    // Fail if the initial key length won't fit in 27 bits.
+    if (header->fInitialKeyLength != desc->keyLength()) {
+        desc->key().reset();
+        return false;
+    }
 
     return true;
 }
diff --git a/src/gpu/GrProgramDesc.h b/src/gpu/GrProgramDesc.h
index 7eaf880..011edfd 100644
--- a/src/gpu/GrProgramDesc.h
+++ b/src/gpu/GrProgramDesc.h
@@ -22,7 +22,7 @@
  */
 class GrProgramDesc {
 public:
-    GrProgramDesc(const GrProgramDesc& other) = default;
+    GrProgramDesc(const GrProgramDesc& other) : fKey(other.fKey) {}   // for SkLRUCache
 
     bool isValid() const { return !fKey.empty(); }
 
@@ -41,7 +41,6 @@
         uint32_t keyLength = other.keyLength();
         fKey.reset(SkToInt(keyLength));
         memcpy(fKey.begin(), other.fKey.begin(), keyLength);
-        fInitialKeyLength = other.fInitialKeyLength;
         return *this;
     }
 
@@ -66,7 +65,7 @@
         return !(*this == other);
     }
 
-    uint32_t initialKeyLength() const { return fInitialKeyLength; }
+    uint32_t initialKeyLength() const { return this->header().fInitialKeyLength; }
 
 protected:
     friend class GrDawnCaps;
@@ -101,11 +100,48 @@
         return true;
     }
 
+    // TODO: this should be removed and converted to just data added to the key
+    struct KeyHeader {
+        // Set to uniquely identify any swizzling of the shader's output color(s).
+        uint16_t fWriteSwizzle;
+        uint8_t fColorFragmentProcessorCnt; // Can be packed into 4 bits if required.
+        uint8_t fCoverageFragmentProcessorCnt;
+        // Set to uniquely identify the rt's origin, or 0 if the shader does not require this info.
+        uint32_t fSurfaceOriginKey : 2;
+        uint32_t fProcessorFeatures : 1;
+        uint32_t fSnapVerticesToPixelCenters : 1;
+        uint32_t fHasPointSize : 1;
+        // This is the key size (in bytes) after core key construction. It doesn't include any
+        // portions added by the platform-specific backends.
+        uint32_t fInitialKeyLength : 27;
+    };
+    static_assert(sizeof(KeyHeader) == 8);
+
+    const KeyHeader& header() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
+
+    template<typename T, size_t OFFSET> T* atOffset() {
+        return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
+    }
+
+    template<typename T, size_t OFFSET> const T* atOffset() const {
+        return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
+    }
+
+    // The key, stored in fKey, is composed of two parts:
+    // 1. Header struct defined above.
+    // 2. A Backend specific payload which includes the per-processor keys.
+    enum KeyOffsets {
+        kHeaderOffset = 0,
+        kHeaderSize = SkAlign4(sizeof(KeyHeader)),
+        // This is the offset into the backend-specific part of the key, which includes
+        // per-processor keys.
+        kProcessorKeysOffset = kHeaderOffset + kHeaderSize,
+    };
+
     enum {
-        kHeaderSize            = 4,    // "header" in ::Build
         kMaxPreallocProcessors = 8,
         kIntsPerProcessor      = 4,    // This is an overestimate of the average effect key size.
-        kPreAllocSize = kHeaderSize +
+        kPreAllocSize = kHeaderOffset + kHeaderSize +
                         kMaxPreallocProcessors * sizeof(uint32_t) * kIntsPerProcessor,
     };
 
@@ -113,7 +149,6 @@
 
 private:
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
-    uint32_t fInitialKeyLength = 0;
 };
 
 #endif