diff --git a/internal/flightplan/matrix.go b/internal/flightplan/matrix.go
index 1b802f1..e6c9a39 100644
--- a/internal/flightplan/matrix.go
+++ b/internal/flightplan/matrix.go
@@ -4,7 +4,6 @@ import (
 	"cmp"
 	"fmt"
 	"slices"
-	"sort"
 	"strings"
 
 	"github.com/zclconf/go-cty/cty"
@@ -103,8 +102,10 @@ func (e Element) Equal(other Element) bool {
 	return true
 }
 
-func NewVector() *Vector {
-	return &Vector{}
+func NewVector(elms ...Element) *Vector {
+	return &Vector{
+		elements: elms,
+	}
 }
 
 // String returns the vector as a string.
@@ -315,6 +316,7 @@ func (v *Vector) SortedElements() []Element {
 	return v.sortedElements
 }
 
+// sort() sorts a vectors shadow sortedElements.
 func (v *Vector) sort() {
 	if v.elements == nil {
 		return
@@ -330,17 +332,24 @@ func (v *Vector) sort() {
 		return
 	}
 
-	slices.SortStableFunc(v.sortedElements, func(a, b Element) int {
-		if i := cmp.Compare(a.Key, b.Key); i != 0 {
-			return i
-		}
-
-		return cmp.Compare(a.Val, b.Val)
-	})
+	slices.SortStableFunc(v.sortedElements, compareElement)
 
 	v.dirty = false
 }
 
+// SortElements sorts a vectors elements.
+func (v *Vector) SortElements() {
+	if v.elements == nil {
+		return
+	}
+
+	if len(v.elements) < 2 {
+		return
+	}
+
+	slices.SortStableFunc(v.elements, compareElement)
+}
+
 // NewVectorFromProto takes a proto filter vector and returns a new Vector.
 func NewVectorFromProto(pbv *pb.Matrix_Vector) *Vector {
 	v := NewVector()
@@ -370,17 +379,33 @@ func (m *Matrix) String() string {
 
 // AddVector adds a vector the matrix.
 func (m *Matrix) AddVector(vec *Vector) {
-	if vec == nil || len(vec.elements) == 0 {
+	if m == nil || vec == nil || len(vec.elements) == 0 {
 		return
 	}
 
 	if m.Vectors == nil {
-		m.Vectors = []*Vector{}
+		m.Vectors = []*Vector{vec}
+		return
 	}
 
 	m.Vectors = append(m.Vectors, vec)
 }
 
+// AddVectorSorted adds a sorted vector to a sorted matrix.
+func (m *Matrix) AddVectorSorted(vec *Vector) {
+	if m == nil || vec == nil || len(vec.elements) == 0 {
+		return
+	}
+
+	if m.Vectors == nil {
+		m.Vectors = []*Vector{vec}
+		return
+	}
+
+	i, _ := slices.BinarySearchFunc(m.Vectors, vec, compareVector)
+	m.Vectors = slices.Insert(m.Vectors, i, vec)
+}
+
 // Copy creates a new Copy of the Matrix.
 func (m *Matrix) Copy() *Matrix {
 	nm := NewMatrix()
@@ -485,6 +510,18 @@ func (m *Matrix) HasVector(other *Vector) bool {
 	return false
 }
 
+// HasVectorSorted returns whether or not a sorted matrix has a sorted vector. It assumes
+// the matrix and vector have both already been sorted.
+func (m *Matrix) HasVectorSorted(other *Vector) bool {
+	if other == nil {
+		return false
+	}
+
+	_, has := slices.BinarySearchFunc(m.Vectors, other, compareVector)
+
+	return has
+}
+
 // HasVectorUnordered returns whether or not a matrix has a vector whose unordered
 // values match exactly with another that is given.
 func (m *Matrix) HasVectorUnordered(other *Vector) bool {
@@ -531,14 +568,37 @@ func (m *Matrix) Unique() *Matrix {
 
 // UniqueValues returns a new Matrix with all Vectors that have unique values.
 func (m *Matrix) UniqueValues() *Matrix {
-	nm := NewMatrix()
-	for _, v := range m.Vectors {
-		if !nm.HasVectorUnordered(v) {
-			nm.AddVector(v)
+	if m == nil {
+		return nil
+	}
+
+	if len(m.Vectors) < 2 {
+		return m.Copy()
+	}
+
+	nmUnsorted := NewMatrix()
+	nmSorted := NewMatrix()
+	for i := range m.Vectors {
+		v := m.Vectors[i].Copy()
+		v.SortElements()
+		if !nmSorted.HasVectorSorted(v) {
+			nmSorted.AddVectorSorted(v)
+			nmUnsorted.AddVector(m.Vectors[i])
 		}
 	}
 
-	return nm
+	return nmUnsorted
+}
+
+// Compact removes duplicate vectors from a matrix
+func (m *Matrix) Compact() {
+	if m == nil || len(m.Vectors) < 2 {
+		return
+	}
+
+	slices.CompactFunc(m.Vectors, func(a, b *Vector) bool {
+		return a.Equal(b)
+	})
 }
 
 // Filter takes a scenario filter returns a new filtered matrix.
@@ -683,23 +743,11 @@ func (m *Matrix) EqualUnordered(other *Matrix) bool {
 	}
 
 	mSorted := m.Copy()
+	mSorted.Sort()
 	otherSorted := other.Copy()
+	otherSorted.Sort()
 
-	sort.Slice(mSorted.Vectors, func(i, j int) bool {
-		return mSorted.Vectors[i].StringSorted() < mSorted.Vectors[j].StringSorted()
-	})
-
-	sort.Slice(otherSorted.Vectors, func(i, j int) bool {
-		return otherSorted.Vectors[i].StringSorted() < otherSorted.Vectors[j].StringSorted()
-	})
-
-	for i := range mSorted.Vectors {
-		if !mSorted.Vectors[i].EqualUnordered(otherSorted.Vectors[i]) {
-			return false
-		}
-	}
-
-	return true
+	return mSorted.Equal(otherSorted)
 }
 
 // Proto returns the matrix as a proto message. If a matrix is created with a scenario filter
@@ -743,6 +791,25 @@ func (m *Matrix) FromProto(in *pb.Matrix) {
 	}
 }
 
+func (m *Matrix) SortVectorElements() {
+	if m == nil {
+		return
+	}
+
+	for i := range m.Vectors {
+		m.Vectors[i].SortElements()
+	}
+}
+
+func (m *Matrix) Sort() {
+	if m == nil || len(m.Vectors) < 1 {
+		return
+	}
+
+	m.SortVectorElements()
+	slices.SortStableFunc(m.Vectors, compareVector)
+}
+
 // Match determines if Exclude directive matches the vector.
 func (ex *Exclude) Match(vec *Vector) bool {
 	if vec == nil {
@@ -788,3 +855,50 @@ func (ex *Exclude) FromProto(pfe *pb.Matrix_Exclude) {
 	ex.Vector = NewVectorFromProto(pfe.GetVector())
 	ex.Mode = pfe.GetMode()
 }
+
+// compareElement takes two elements and does a sort commparison
+func compareElement(a, b Element) int {
+	if iv := cmp.Compare(a.Key, b.Key); iv != 0 {
+		return iv
+	}
+
+	return cmp.Compare(a.Val, b.Val)
+}
+
+// compareVector takes two vectors and does a sort comparison.
+func compareVector(a, b *Vector) int {
+	// Compare by existence
+	if a == nil && b == nil {
+		return 0
+	}
+
+	if a != nil && b == nil {
+		return 1
+	}
+
+	if a == nil && b != nil {
+		return -1
+	}
+
+	// Compare by number of variants
+	var aElms, bElms []Element
+	if len(a.elements) > 0 {
+		aElms = a.elements
+	}
+	if len(b.elements) > 0 {
+		bElms = b.elements
+	}
+	if i := cmp.Compare(len(aElms), len(bElms)); i != 0 {
+		return i
+	}
+
+	// Compare by element value
+	for i := range a.elements {
+		if iv := compareElement(a.elements[i], b.elements[i]); iv != 0 {
+			return iv
+		}
+	}
+
+	// We have equal vectors
+	return 0
+}
diff --git a/internal/flightplan/matrix_benchmark_test.go b/internal/flightplan/matrix_benchmark_test.go
new file mode 100644
index 0000000..bc75e54
--- /dev/null
+++ b/internal/flightplan/matrix_benchmark_test.go
@@ -0,0 +1,25 @@
+package flightplan
+
+import (
+	"testing"
+)
+
+var benchmarkMatrix = &Matrix{Vectors: []*Vector{
+	NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+	NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+	NewVector(NewElement("source", "local"), NewElement("source", "crt"), NewElement("source", "art")),
+	NewVector(NewElement("type", "bundle"), NewElement("source", "package")),
+	NewVector(NewElement("backend_ver", "1.14.2"), NewElement("backend_ver", "1.13.2"), NewElement("backend_ver", "1.12.2"), NewElement("backend_ver", "1.11.2")),
+	NewVector(NewElement("distro", "rhel"), NewElement("distro", "ubuntu")),
+	NewVector(NewElement("edition", "ce"), NewElement("edition", "ent"), NewElement("edition", "ent.hms"), NewElement("edition", "ent.fips1402"), NewElement("edition", "ent.hsm.fips1402")),
+	NewVector(NewElement("seal", "shamir"), NewElement("awskms", "awkms")),
+}}
+
+func Benchmark_Matrix_UniqueValues(b *testing.B) {
+	b.Run("UniqueValuesNew", func(b *testing.B) {
+		benchmarkMatrix.Copy().CartesianProduct().UniqueValues()
+	})
+	b.Run("UniqueValuesOld", func(b *testing.B) {
+		benchmarkMatrix.Copy().CartesianProduct().UniqueValuesOld()
+	})
+}
diff --git a/internal/flightplan/matrix_test.go b/internal/flightplan/matrix_test.go
index 50081c7..ea38e91 100644
--- a/internal/flightplan/matrix_test.go
+++ b/internal/flightplan/matrix_test.go
@@ -231,7 +231,7 @@ scenario "nighttime" {
 						Scenarios: []*Scenario{
 							{
 								Name:         "nighttime",
-								Variants:     &Vector{elements: []Element{NewElement("cathat", "conrad"), NewElement("onefish", "twofish")}},
+								Variants:     NewVector(NewElement("cathat", "conrad"), NewElement("onefish", "twofish")),
 								TerraformCLI: DefaultTerraformCLI(),
 								Steps: []*ScenarioStep{
 									{
@@ -249,7 +249,7 @@ scenario "nighttime" {
 							},
 							{
 								Name:         "nighttime",
-								Variants:     &Vector{elements: []Element{NewElement("cathat", "sally"), NewElement("onefish", "twofish")}},
+								Variants:     NewVector(NewElement("cathat", "sally"), NewElement("onefish", "twofish")),
 								TerraformCLI: DefaultTerraformCLI(),
 								Steps: []*ScenarioStep{
 									{
@@ -267,7 +267,7 @@ scenario "nighttime" {
 							},
 							{
 								Name:         "nighttime",
-								Variants:     &Vector{elements: []Element{NewElement("cathat", "thing2"), NewElement("onefish", "bluefish")}},
+								Variants:     NewVector(NewElement("cathat", "thing2"), NewElement("onefish", "bluefish")),
 								TerraformCLI: DefaultTerraformCLI(),
 								Steps: []*ScenarioStep{
 									{
@@ -285,7 +285,7 @@ scenario "nighttime" {
 							},
 							{
 								Name:         "nighttime",
-								Variants:     &Vector{elements: []Element{NewElement("cathat", "thing2"), NewElement("onefish", "redfish")}},
+								Variants:     NewVector(NewElement("cathat", "thing2"), NewElement("onefish", "redfish")),
 								TerraformCLI: DefaultTerraformCLI(),
 								Steps: []*ScenarioStep{
 									{
@@ -332,18 +332,18 @@ func Test_Matrix_Vector_Equal(t *testing.T) {
 		equal bool
 	}{
 		"equal": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			true,
 		},
 		"ordered but unequal Elements": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			false,
 		},
 		"equal Values": {
-			&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			false,
 		},
 	} {
@@ -364,28 +364,28 @@ func Test_Matrix_Vector_ContainsUnordered(t *testing.T) {
 		match bool
 	}{
 		"exact": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			true,
 		},
 		"unordered unequal len match": {
-			&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
+			NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
 			false,
 		},
 		"unordered exact": {
-			&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			true,
 		},
 		"equal len no match": {
-			&Vector{elements: []Element{NewElement("backend", "myssql"), NewElement("backend", "raft")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "myssql"), NewElement("backend", "raft")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			false,
 		},
 		"unequal len no match": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
 			false,
 		},
 	} {
@@ -406,18 +406,18 @@ func Test_Matrix_Vector_EqualUnordered(t *testing.T) {
 		equal bool
 	}{
 		"equal": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			true,
 		},
 		"ordered but unequal Elements": {
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			false,
 		},
 		"equal Values": {
-			&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-			&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+			NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+			NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 			true,
 		},
 	} {
@@ -446,47 +446,47 @@ func Test_Matrix_CartesianProduct(t *testing.T) {
 		},
 		"regular": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("distro", "ubuntu"), NewElement("distro", "rhel")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")),
+				NewVector(NewElement("distro", "ubuntu"), NewElement("distro", "rhel")),
 			}},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "rhel")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "rhel")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "rhel")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "rhel")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "rhel")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "rhel")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "rhel")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "rhel")),
 			}},
 		},
 		"irregular": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")}},
-				{elements: []Element{NewElement("distro", "ubuntu")}},
-				{elements: []Element{NewElement("test", "fresh-install"), NewElement("test", "upgrade"), NewElement("test", "security")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")),
+				NewVector(NewElement("distro", "ubuntu")),
+				NewVector(NewElement("test", "fresh-install"), NewElement("test", "upgrade"), NewElement("test", "security")),
 			}},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "security")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "fresh-install")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "upgrade")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "ppc64"), NewElement("distro", "ubuntu"), NewElement("test", "security")),
 			}},
 		},
 	} {
@@ -512,18 +512,18 @@ func Test_Matrix_UniqueValues(t *testing.T) {
 	t.Parallel()
 
 	m1 := NewMatrix()
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}})
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")))
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m1.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")))
+	m1.AddVector(NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")))
 
 	m2 := NewMatrix()
-	m2.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")}})
+	m2.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")))
+	m2.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m2.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m2.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")))
 
 	uniq := m1.UniqueValues()
 	require.Len(t, uniq.Vectors, len(m2.Vectors))
@@ -533,13 +533,58 @@ func Test_Matrix_UniqueValues(t *testing.T) {
 	}
 }
 
+func Test_Matrix_HasVectorSorted(t *testing.T) {
+	t.Parallel()
+
+	m1 := NewMatrix()
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")))
+	m1.AddVector(NewVector(NewElement("backend", "mysql"), NewElement("backend", "postgres"), NewElement("backend", "mssql")))
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m1.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")))
+	m1.AddVector(NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")))
+
+	m1.Sort()
+	for desc, test := range map[string]struct {
+		has bool
+		vec *Vector
+	}{
+		"not there": {
+			has: false,
+			vec: NewVector(NewElement("arch", "s390x"), NewElement("arch", "arm64")),
+		},
+		"partial ordered": {
+			has: false,
+			vec: NewVector(NewElement("backend", "mysql"), NewElement("backend", "postgres")),
+		},
+		"unorderd": {
+			has: true,
+			vec: NewVector(NewElement("backend", "mssql"), NewElement("backend", "consul"), NewElement("backend", "raft")),
+		},
+		"in order": {
+			has: true,
+			vec: NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64"), NewElement("arch", "ppc64")),
+		},
+	} {
+		desc := desc
+		test := test
+		t.Run(desc, func(t *testing.T) {
+			t.Parallel()
+			test.vec.SortElements()
+			has := m1.HasVectorSorted(test.vec)
+			require.Equal(t, test.has, has)
+		})
+	}
+}
+
 func Test_Matrix_Proto_RoundTrip(t *testing.T) {
 	t.Parallel()
 	expected := &Matrix{Vectors: []*Vector{
-		{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-		{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-		{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-		{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+		NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+		NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+		NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+		NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 	}}
 
 	got := NewMatrix()
@@ -551,21 +596,21 @@ func Test_Matrix_Unique(t *testing.T) {
 	t.Parallel()
 
 	m1 := NewMatrix()
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "myssql")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}})
-	m1.AddVector(&Vector{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}})
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m1.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m1.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "myssql")))
+	m1.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")))
+	m1.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m1.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m1.AddVector(NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")))
 
 	m2 := NewMatrix()
-	m2.AddVector(&Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "myssql")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}})
-	m2.AddVector(&Vector{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}})
+	m2.AddVector(NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")))
+	m2.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "myssql")))
+	m2.AddVector(NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")))
+	m2.AddVector(NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")))
+	m2.AddVector(NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")))
 
 	require.Equal(t, m2, m1.Unique())
 }
@@ -580,96 +625,96 @@ func Test_Matrix_Filter_Filter_Parse(t *testing.T) {
 	}{
 		"all": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			"",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			"backend:raft",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			"backend:raft arch:amd64",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 		"exclude-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			"!arch:amd64",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 		},
 		"exclude-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			"!arch:amd64 !backend:consul",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-and-exclude-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			"!arch:amd64 backend:raft",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
 			}},
 		},
 		"include-and-exclude-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			"!arch:amd64 !backend:raft arch:aarch64",
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 		},
 	} {
@@ -694,239 +739,219 @@ func Test_Matrix_Filter_ScenarioFilter(t *testing.T) {
 	}{
 		"all": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			&ScenarioFilter{SelectAll: true},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			&ScenarioFilter{
-				Include: &Vector{elements: []Element{NewElement("backend", "raft")}},
+				Include: NewVector(NewElement("backend", "raft")),
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			&ScenarioFilter{
-				Include: &Vector{
-					elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")},
-				},
+				Include: NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 		"exclude-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			&ScenarioFilter{
 				Exclude: []*Exclude{
 					{
 						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{elements: []Element{NewElement("backend", "raft")}},
+						Vector: NewVector(NewElement("backend", "raft")),
 					},
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 		},
 		"exclude-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 			&ScenarioFilter{
 				Exclude: []*Exclude{
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("arch", "amd64")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("arch", "amd64")),
 					},
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("backend", "consul")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("backend", "consul")),
 					},
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 		"include-and-exclude-one": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			&ScenarioFilter{
-				Include: &Vector{
-					elements: []Element{NewElement("backend", "raft")},
-				},
+				Include: NewVector(NewElement("backend", "raft")),
 				Exclude: []*Exclude{
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("arch", "amd64")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("arch", "amd64")),
 					},
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
 			}},
 		},
 		"include-and-exclude-some": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			&ScenarioFilter{
-				Include: &Vector{
-					elements: []Element{NewElement("arch", "aarch64")},
-				},
+				Include: NewVector(NewElement("arch", "aarch64")),
 				Exclude: []*Exclude{
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("arch", "amd64")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("arch", "amd64")),
 					},
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("backend", "raft")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("backend", "raft")),
 					},
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 		},
 		"intersection-matrix": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			&ScenarioFilter{
 				IntersectionMatrix: &Matrix{Vectors: []*Vector{
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 				}},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 		},
 		"intersection-matrix-with-exclude": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			&ScenarioFilter{
 				Exclude: []*Exclude{
 					{
-						Mode: pb.Matrix_Exclude_MODE_CONTAINS,
-						Vector: &Vector{
-							elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")},
-						},
+						Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
+						Vector: NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 					},
 				},
 				IntersectionMatrix: &Matrix{Vectors: []*Vector{
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 				}},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 		},
 		"intersection-matrix-with-include": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "aarch64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "aarch64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 			}},
 			&ScenarioFilter{
-				Include: &Vector{
-					elements: []Element{NewElement("backend", "raft")},
-				},
+				Include: NewVector(NewElement("backend", "raft")),
 				IntersectionMatrix: &Matrix{Vectors: []*Vector{
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "aarch64")}},
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "aarch64")),
 				}},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 	} {
@@ -954,57 +979,57 @@ func Test_Matrix_Equal(t *testing.T) {
 		"in-nil": {
 			in: new(Matrix),
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: false,
 		},
 		"other-nil": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other:    new(Matrix),
 			expected: false,
 		},
 		"unbalanced-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: false,
 		},
 		"balanced-different-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("howdy", "partner"), NewElement("hey", "pal")}},
-				{elements: []Element{NewElement("howdy", "friend"), NewElement("hey", "guy")}},
+				NewVector(NewElement("howdy", "partner"), NewElement("hey", "pal")),
+				NewVector(NewElement("howdy", "friend"), NewElement("hey", "guy")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: false,
 		},
 		"unordered-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: false,
 		},
 		"equal": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: true,
 		},
@@ -1034,68 +1059,68 @@ func Test_Matrix_EqualUnordered(t *testing.T) {
 		"in-nil": {
 			in: new(Matrix),
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: false,
 		},
 		"other-nil": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other:    new(Matrix),
 			expected: false,
 		},
 		"unbalanced-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: false,
 		},
 		"balanced-different-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("howdy", "partner"), NewElement("hey", "pal")}},
-				{elements: []Element{NewElement("howdy", "friend"), NewElement("hey", "guy")}},
+				NewVector(NewElement("howdy", "partner"), NewElement("hey", "pal")),
+				NewVector(NewElement("howdy", "friend"), NewElement("hey", "guy")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: false,
 		},
 		"unordered-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: true,
 		},
 		"unordered-elements-and-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("arch", "arm32"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("backend", "raft")}},
+				NewVector(NewElement("arch", "arm32"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("backend", "raft")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: true,
 		},
 		"equal": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: true,
 		},
@@ -1119,107 +1144,107 @@ func Test_Matrix_Exclude(t *testing.T) {
 	}{
 		"nil": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 			nil,
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 		},
 		"empty": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 			[]*Exclude{},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 		},
 		"exact": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 			[]*Exclude{
 				{
 					Mode:   pb.Matrix_Exclude_MODE_EXACTLY,
-					Vector: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+					Vector: NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 				},
 				{
 					Mode:   pb.Matrix_Exclude_MODE_EXACTLY,
-					Vector: &Vector{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+					Vector: NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
 			}},
 		},
 		"equal values": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 			[]*Exclude{
 				{
 					Mode:   pb.Matrix_Exclude_MODE_EQUAL_UNORDERED,
-					Vector: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul")}},
+					Vector: NewVector(NewElement("backend", "raft"), NewElement("backend", "consul")),
 				},
 				{
 					Mode:   pb.Matrix_Exclude_MODE_EQUAL_UNORDERED,
-					Vector: &Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "amd64")}},
+					Vector: NewVector(NewElement("arch", "arm64"), NewElement("arch", "amd64")),
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
 			}},
 		},
 		"match": {
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "mysql")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "mysql"), NewElement("backend", "mssql")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
+				NewVector(NewElement("backend", "consul"), NewElement("backend", "raft"), NewElement("backend", "mysql")),
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "mysql"), NewElement("backend", "mssql")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "arm32")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("arch", "arm32")),
 			}},
 			[]*Exclude{
 				{
 					Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
-					Vector: &Vector{elements: []Element{NewElement("backend", "mysql")}},
+					Vector: NewVector(NewElement("backend", "mysql")),
 				},
 				{
 					Mode:   pb.Matrix_Exclude_MODE_CONTAINS,
-					Vector: &Vector{elements: []Element{NewElement("arch", "arm64"), NewElement("arch", "arm32")}},
+					Vector: NewVector(NewElement("arch", "arm64"), NewElement("arch", "arm32")),
 				},
 			},
 			&Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("backend", "consul"), NewElement("backend", "mssql")),
+				NewVector(NewElement("arch", "amd64"), NewElement("arch", "arm64"), NewElement("arch", "ppc64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
 			}},
 		},
 	} {
@@ -1248,80 +1273,80 @@ func Test_Matrix_IntersectionUnordered(t *testing.T) {
 		"in-nil": {
 			in: nil,
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: nil,
 		},
 		"other-nil": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other:    nil,
 			expected: nil,
 		},
 		"unbalanced-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 		"balanced-different-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("howdy", "partner"), NewElement("hey", "pal")}},
-				{elements: []Element{NewElement("howdy", "friend"), NewElement("hey", "guy")}},
+				NewVector(NewElement("howdy", "partner"), NewElement("hey", "pal")),
+				NewVector(NewElement("howdy", "friend"), NewElement("hey", "guy")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: nil,
 		},
 		"unordered-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 		},
 		"unordered-elements-and-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("arch", "arm32"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("backend", "raft")}},
+				NewVector(NewElement("arch", "arm32"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("backend", "raft")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 		},
 		"equal": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 	} {
@@ -1351,79 +1376,79 @@ func Test_Matrix_SymmetricDifferenceUnordered(t *testing.T) {
 		"in-nil": {
 			in: nil,
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 		"other-nil": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: nil,
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 		},
 		"unbalanced-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 		},
 		"balanced-different-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("howdy", "partner"), NewElement("hey", "pal")}},
-				{elements: []Element{NewElement("howdy", "friend"), NewElement("hey", "guy")}},
+				NewVector(NewElement("howdy", "partner"), NewElement("hey", "pal")),
+				NewVector(NewElement("howdy", "friend"), NewElement("hey", "guy")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("howdy", "partner"), NewElement("hey", "pal")}},
-				{elements: []Element{NewElement("howdy", "friend"), NewElement("hey", "guy")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("howdy", "partner"), NewElement("hey", "pal")),
+				NewVector(NewElement("howdy", "friend"), NewElement("hey", "guy")),
 			}},
 		},
 		"unordered-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: nil,
 		},
 		"unordered-elements-and-vertices": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("arch", "arm32"), NewElement("backend", "raft")}},
-				{elements: []Element{NewElement("arch", "amd64"), NewElement("backend", "raft")}},
+				NewVector(NewElement("arch", "arm32"), NewElement("backend", "raft")),
+				NewVector(NewElement("arch", "amd64"), NewElement("backend", "raft")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
 			}},
 			expected: nil,
 		},
 		"equal": {
 			in: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			other: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm32")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm32")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
 			}},
 			expected: nil,
 		},
diff --git a/internal/flightplan/sample_frame_test.go b/internal/flightplan/sample_frame_test.go
index 4cea347..aae92ea 100644
--- a/internal/flightplan/sample_frame_test.go
+++ b/internal/flightplan/sample_frame_test.go
@@ -580,26 +580,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -617,26 +605,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -654,26 +630,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -691,26 +655,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -728,26 +680,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -765,26 +705,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -802,26 +730,14 @@ func Test_SampleFrame_FilterMinMax(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -883,26 +799,14 @@ func Test_SampleFrame_Size(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -914,14 +818,8 @@ func Test_SampleFrame_Size(t *testing.T) {
 				SubsetFrames: SampleSubsetFrames{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz": {
@@ -937,14 +835,8 @@ func Test_SampleFrame_Size(t *testing.T) {
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
diff --git a/internal/flightplan/sample_funcs_test.go b/internal/flightplan/sample_funcs_test.go
index 6ad0be1..fad9186 100644
--- a/internal/flightplan/sample_funcs_test.go
+++ b/internal/flightplan/sample_funcs_test.go
@@ -116,14 +116,8 @@ func Test_SampleFuncAll(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
@@ -131,14 +125,8 @@ func Test_SampleFuncAll(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -154,26 +142,14 @@ func Test_SampleFuncAll(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -191,14 +167,8 @@ func Test_SampleFuncAll(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz": {
@@ -217,14 +187,8 @@ func Test_SampleFuncAll(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -239,28 +203,16 @@ func Test_SampleFuncAll(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz":       {},
 					"baz_alias": {},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -458,14 +410,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
@@ -473,14 +419,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -489,10 +429,7 @@ func Test_SampleFuncStratified(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 				},
@@ -511,14 +448,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
@@ -526,14 +457,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -549,18 +474,12 @@ func Test_SampleFuncStratified(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -578,14 +497,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz": {
@@ -604,14 +517,8 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -620,20 +527,14 @@ func Test_SampleFuncStratified(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz":       {},
 					"baz_alias": {},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
@@ -652,30 +553,12 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "aarch64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "aarch64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "aarch64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "aarch64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 					"baz": {
@@ -694,22 +577,10 @@ func Test_SampleFuncStratified(t *testing.T) {
 							Name: "bar",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 				},
@@ -725,40 +596,19 @@ func Test_SampleFuncStratified(t *testing.T) {
 				SubsetObservations: SampleSubsetObservations{
 					"foo": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "aarch64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "aarch64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
 						}},
 					},
 					"baz":       {},
 					"baz_alias": {},
 					"bar": {
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "amd64"),
-								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
-								NewElement("arch", "arm64"),
-								NewElement("primary_backend", "raft"),
-							}},
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "consul")),
+							NewVector(NewElement("arch", "amd64"), NewElement("primary_backend", "raft")),
+							NewVector(NewElement("arch", "arm64"), NewElement("primary_backend", "raft")),
 						}},
 					},
 				},
diff --git a/internal/flightplan/sample_subset_test.go b/internal/flightplan/sample_subset_test.go
index df7ca8a..108c0f9 100644
--- a/internal/flightplan/sample_subset_test.go
+++ b/internal/flightplan/sample_subset_test.go
@@ -86,10 +86,10 @@ sample "foodle" {
 						}),
 					},
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw1")}},
-						{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw3")}},
-						{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw1")}},
-						{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw3")}},
+						NewVector(NewElement("length", "fl2"), NewElement("width", "fw1")),
+						NewVector(NewElement("length", "fl2"), NewElement("width", "fw3")),
+						NewVector(NewElement("length", "fl3"), NewElement("width", "fw1")),
+						NewVector(NewElement("length", "fl3"), NewElement("width", "fw3")),
 					}},
 					ScenarioFilter: &pb.Scenario_Filter{
 						Name: "foo",
@@ -101,9 +101,9 @@ sample "foodle" {
 						ScenarioFilter: "bar length:bl1",
 					},
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw1")}},
-						{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw2")}},
-						{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw3")}},
+						NewVector(NewElement("length", "bl1"), NewElement("width", "bw1")),
+						NewVector(NewElement("length", "bl1"), NewElement("width", "bw2")),
+						NewVector(NewElement("length", "bl1"), NewElement("width", "bw3")),
 					}},
 					ScenarioFilter: &pb.Scenario_Filter{
 						Name: "bar",
@@ -149,15 +149,15 @@ sample "foo" {
 						Name: "foo",
 					},
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw1")}},
-						{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw2")}},
-						{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw3")}},
-						{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw1")}},
-						{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw2")}},
-						{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw3")}},
-						{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw1")}},
-						{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw2")}},
-						{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw3")}},
+						NewVector(NewElement("length", "fl1"), NewElement("width", "fw1")),
+						NewVector(NewElement("length", "fl1"), NewElement("width", "fw2")),
+						NewVector(NewElement("length", "fl1"), NewElement("width", "fw3")),
+						NewVector(NewElement("length", "fl2"), NewElement("width", "fw1")),
+						NewVector(NewElement("length", "fl2"), NewElement("width", "fw2")),
+						NewVector(NewElement("length", "fl2"), NewElement("width", "fw3")),
+						NewVector(NewElement("length", "fl3"), NewElement("width", "fw1")),
+						NewVector(NewElement("length", "fl3"), NewElement("width", "fw2")),
+						NewVector(NewElement("length", "fl3"), NewElement("width", "fw3")),
 					}},
 					ScenarioFilter: &pb.Scenario_Filter{
 						Name: "foo",
diff --git a/internal/flightplan/sample_test.go b/internal/flightplan/sample_test.go
index eab59e9..9f182ae 100644
--- a/internal/flightplan/sample_test.go
+++ b/internal/flightplan/sample_test.go
@@ -123,22 +123,22 @@ variable "input" {}
 									"continue-on-error": cty.BoolVal(true),
 								}),
 								Matrix: &Matrix{Vectors: []*Vector{
-									{elements: []Element{
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "package"),
 										NewElement("distro", "rhel"),
 										NewElement("edition", "ent.hsm"),
 										NewElement("primary_backend", "consul"),
-									}},
-									{elements: []Element{
+									),
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "package"),
 										NewElement("distro", "ubuntu"),
 										NewElement("edition", "ent.hsm"),
 										NewElement("primary_backend", "consul"),
-									}},
+									),
 								}},
 							},
 							{
@@ -149,56 +149,56 @@ variable "input" {}
 									"another_thing": cty.StringVal("another"),
 								}),
 								Matrix: &Matrix{Vectors: []*Vector{
-									{elements: []Element{
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "bundle"),
 										NewElement("distro", "rhel"),
 										NewElement("edition", "ent.hsm"),
 										NewElement("primary_backend", "raft"),
-									}},
-									{elements: []Element{
+									),
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "bundle"),
 										NewElement("distro", "centos"),
 										NewElement("edition", "ent.hsm"),
 										NewElement("primary_backend", "raft"),
-									}},
-									{elements: []Element{
+									),
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "bundle"),
 										NewElement("distro", "amz"),
 										NewElement("edition", "ent.hsm"),
 										NewElement("primary_backend", "raft"),
-									}},
+									),
 								}},
 							},
 							{
 								Name: "smoke",
 								Matrix: &Matrix{Vectors: []*Vector{
-									{elements: []Element{
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "package"),
 										NewElement("distro", "rhel"),
 										NewElement("edition", "ent.hsm"),
-									}},
-									{elements: []Element{
+									),
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "package"),
 										NewElement("distro", "centos"),
 										NewElement("edition", "ent.hsm"),
-									}},
-									{elements: []Element{
+									),
+									NewVector(
 										NewElement("arch", "amd64"),
 										NewElement("artifact_source", "artifactory"),
 										NewElement("artifact_type", "package"),
 										NewElement("distro", "amz"),
 										NewElement("edition", "ent.hsm"),
-									}},
+									),
 								}},
 							},
 							{
@@ -410,10 +410,10 @@ sample "foodle" {
 							}),
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw3")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw3")}},
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw3")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw3")),
 						}},
 						ScenarioFilter: &pb.Scenario_Filter{
 							Name: "foo",
@@ -425,9 +425,9 @@ sample "foodle" {
 							ScenarioFilter: "bar length:bl1",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw1")}},
-							{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw2")}},
-							{elements: []Element{NewElement("length", "bl1"), NewElement("width", "bw3")}},
+							NewVector(NewElement("length", "bl1"), NewElement("width", "bw1")),
+							NewVector(NewElement("length", "bl1"), NewElement("width", "bw2")),
+							NewVector(NewElement("length", "bl1"), NewElement("width", "bw3")),
 						}},
 						ScenarioFilter: &pb.Scenario_Filter{
 							Name: "bar",
@@ -475,15 +475,15 @@ sample "foo" {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw2")}},
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw3")}},
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw2")}},
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw3")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw2")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw3")}},
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw2")),
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw3")),
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw2")),
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw3")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw2")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw3")),
 						}},
 						ScenarioFilter: &pb.Scenario_Filter{
 							Name: "foo",
@@ -546,10 +546,10 @@ sample "foodle" {
 							Name: "foo",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl2"), NewElement("width", "fw3")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl3"), NewElement("width", "fw3")}},
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl2"), NewElement("width", "fw3")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl3"), NewElement("width", "fw3")),
 						}},
 						ScenarioFilter: &pb.Scenario_Filter{
 							Name: "foo",
@@ -613,9 +613,9 @@ sample "foodle" {
 							ScenarioFilter: "bar length:bl1",
 						},
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw1")}},
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw2")}},
-							{elements: []Element{NewElement("length", "fl1"), NewElement("width", "fw3")}},
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw1")),
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw2")),
+							NewVector(NewElement("length", "fl1"), NewElement("width", "fw3")),
 						}},
 						ScenarioFilter: &pb.Scenario_Filter{
 							Name: "bar",
@@ -696,22 +696,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"continue-on-error": cty.BoolVal(true),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "ubuntu"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
+							),
 						}},
 					},
 					{
@@ -722,56 +722,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"another_thing": cty.StringVal("another"),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
+							),
 						}},
 					},
 					{
 						Name: "smoke",
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
-							}},
+							),
 						}},
 					},
 					{
@@ -789,22 +789,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 						"continue-on-error": cty.BoolVal(true),
 					}),
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "consul"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "ubuntu"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "consul"),
-						}},
+						),
 					}},
 				},
 				{
@@ -815,56 +815,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 						"another_thing": cty.StringVal("another"),
 					}),
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "centos"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "amz"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
+						),
 					}},
 				},
 				{
 					Name: "smoke",
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "centos"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "amz"),
 							NewElement("edition", "ent.hsm"),
-						}},
+						),
 					}},
 				},
 				{
@@ -888,22 +888,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"continue-on-error": cty.BoolVal(true),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "ubuntu"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
+							),
 						}},
 					},
 					{
@@ -914,56 +914,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"another_thing": cty.StringVal("another"),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
+							),
 						}},
 					},
 					{
 						Name: "smoke",
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
-							}},
+							),
 						}},
 					},
 					{
@@ -990,22 +990,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 						"continue-on-error": cty.BoolVal(true),
 					}),
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "consul"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "ubuntu"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "consul"),
-						}},
+						),
 					}},
 				},
 				{
@@ -1029,22 +1029,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"continue-on-error": cty.BoolVal(true),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "ubuntu"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
+							),
 						}},
 					},
 					{
@@ -1055,56 +1055,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"another_thing": cty.StringVal("another"),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
+							),
 						}},
 					},
 					{
 						Name: "smoke",
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
-							}},
+							),
 						}},
 					},
 					{
@@ -1132,56 +1132,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 						"another_thing": cty.StringVal("another"),
 					}),
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "centos"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "bundle"),
 							NewElement("distro", "amz"),
 							NewElement("edition", "ent.hsm"),
 							NewElement("primary_backend", "raft"),
-						}},
+						),
 					}},
 				},
 				{
 					Name: "smoke",
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "centos"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "amz"),
 							NewElement("edition", "ent.hsm"),
-						}},
+						),
 					}},
 				},
 			},
@@ -1201,22 +1201,22 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"continue-on-error": cty.BoolVal(true),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "ubuntu"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "consul"),
-							}},
+							),
 						}},
 					},
 					{
@@ -1227,56 +1227,56 @@ func Test_Sample_filterSubsets(t *testing.T) {
 							"another_thing": cty.StringVal("another"),
 						}),
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "bundle"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
 								NewElement("primary_backend", "raft"),
-							}},
+							),
 						}},
 					},
 					{
 						Name: "smoke",
 						Matrix: &Matrix{Vectors: []*Vector{
-							{elements: []Element{
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "rhel"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "centos"),
 								NewElement("edition", "ent.hsm"),
-							}},
-							{elements: []Element{
+							),
+							NewVector(
 								NewElement("arch", "amd64"),
 								NewElement("artifact_source", "artifactory"),
 								NewElement("artifact_type", "package"),
 								NewElement("distro", "amz"),
 								NewElement("edition", "ent.hsm"),
-							}},
+							),
 						}},
 					},
 					{
@@ -1310,27 +1310,27 @@ func Test_Sample_filterSubsets(t *testing.T) {
 				{
 					Name: "smoke",
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "rhel"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "centos"),
 							NewElement("edition", "ent.hsm"),
-						}},
-						{elements: []Element{
+						),
+						NewVector(
 							NewElement("arch", "amd64"),
 							NewElement("artifact_source", "artifactory"),
 							NewElement("artifact_type", "package"),
 							NewElement("distro", "amz"),
 							NewElement("edition", "ent.hsm"),
-						}},
+						),
 					}},
 				},
 			},
diff --git a/internal/flightplan/scenario_decoder.go b/internal/flightplan/scenario_decoder.go
index 775c411..2014822 100644
--- a/internal/flightplan/scenario_decoder.go
+++ b/internal/flightplan/scenario_decoder.go
@@ -4,6 +4,7 @@ import (
 	"cmp"
 	"context"
 	"fmt"
+	"runtime"
 	"slices"
 	"sync"
 
@@ -186,14 +187,14 @@ func (d *ScenarioDecoder) DecodeScenarioBlocks(ctx context.Context, blocks []*hc
 			switch d.DecodeTarget {
 			case DecodeTargetScenariosNamesExpandVariants:
 				switch {
-				case len(scenarioBlocks[i].Matrix.Vectors) < 8_000:
+				case runtime.NumCPU() < 2:
 					d.decodeScenariosSerial(scenarioBlocks[i])
 				default:
 					d.decodeScenariosConcurrent(ctx, scenarioBlocks[i])
 				}
 			case DecodeTargetScenariosComplete, DecodeTargetAll:
 				switch {
-				case len(scenarioBlocks[i].Matrix.Vectors) < 100:
+				case runtime.NumCPU() < 2:
 					d.decodeScenariosSerial(scenarioBlocks[i])
 				default:
 					d.decodeScenariosConcurrent(ctx, scenarioBlocks[i])
@@ -209,7 +210,7 @@ func (d *ScenarioDecoder) DecodeScenarioBlocks(ctx context.Context, blocks []*hc
 			}
 		}
 
-		slices.SortStableFunc(scenarioBlocks[i].Scenarios, sortCompareScenarios)
+		slices.SortStableFunc(scenarioBlocks[i].Scenarios, compareScenarios)
 	}
 
 	slices.SortStableFunc(scenarioBlocks, func(a, b *DecodedScenarioBlock) int {
@@ -219,9 +220,9 @@ func (d *ScenarioDecoder) DecodeScenarioBlocks(ctx context.Context, blocks []*hc
 	return scenarioBlocks
 }
 
-// sortCompareScenarios takes two scenarios and does a sort comparison. At present we only factor
+// compareScenarios takes two scenarios and does a sort comparison. At present we only factor
 // in existence, name, and variants into equality.
-func sortCompareScenarios(a, b *Scenario) int {
+func compareScenarios(a, b *Scenario) int {
 	// Compare by existence
 	if a == nil && b == nil {
 		return 0
@@ -240,31 +241,8 @@ func sortCompareScenarios(a, b *Scenario) int {
 		return i
 	}
 
-	// Compare by number of variants
-	var aElms, bElms []Element
-	if a.Variants != nil && len(a.Variants.elements) > 0 {
-		aElms = a.Variants.elements
-	}
-	if b.Variants != nil && len(b.Variants.elements) > 0 {
-		bElms = b.Variants.elements
-	}
-	if i := cmp.Compare(len(aElms), len(bElms)); i != 0 {
-		return i
-	}
-
-	// Compare by element value
-	for i := range a.Variants.elements {
-		if iv := cmp.Compare(a.Variants.elements[i].Key, b.Variants.elements[i].Key); iv != 0 {
-			return iv
-		}
-
-		if iv := cmp.Compare(a.Variants.elements[i].Val, b.Variants.elements[i].Val); iv != 0 {
-			return iv
-		}
-	}
-
-	// We have equal scenarios
-	return 0
+	// Compare by variant vectors
+	return compareVector(a.Variants, b.Variants)
 }
 
 // filterScenarioBlocks takes a slice of hcl.Blocks's and returns our base set of filtered
@@ -343,7 +321,7 @@ func (d *ScenarioDecoder) decodeScenariosSerial(sb *DecodedScenarioBlock) {
 // decodeScenariosConcurrent decodes scenario variants concurrently. This is for improved speeds
 // when fully decoding lots of scenarios.
 func (d *ScenarioDecoder) decodeScenariosConcurrent(ctx context.Context, sb *DecodedScenarioBlock) {
-	if sb.Matrix == nil || len(sb.Matrix.Vectors) < 1 {
+	if sb.Matrix == nil || len(sb.Matrix.Vectors) < 1 || runtime.NumCPU() < 2 {
 		d.decodeScenariosSerial(sb)
 
 		return
@@ -354,38 +332,66 @@ func (d *ScenarioDecoder) decodeScenariosConcurrent(ctx context.Context, sb *Dec
 
 	diagC := make(chan hcl.Diagnostics)
 	scenarioC := make(chan *Scenario)
+	doneC := make(chan struct{})
+	vectorC := make(chan *Vector)
 	wg := sync.WaitGroup{}
 	scenarios := []*Scenario{}
 	diags := hcl.Diagnostics{}
-	doneC := make(chan struct{})
-
-	collect := func() {
+	defer func() {
+		close(diagC)
+		close(scenarioC)
+		close(vectorC)
+		close(doneC)
+	}()
+
+	collectDiags := func() {
 		for {
 			select {
 			case <-collectCtx.Done():
-				close(doneC)
-
 				return
 			case diag := <-diagC:
 				diags = diags.Extend(diag)
+			}
+		}
+	}
+	go collectDiags()
+
+	collectScenarios := func() {
+		for {
+			select {
+			case <-collectCtx.Done():
+				return
 			case scenario := <-scenarioC:
 				scenarios = append(scenarios, scenario)
+				wg.Done()
 			}
 		}
 	}
+	go collectScenarios()
 
-	go collect()
+	decodeScenario := func() {
+		for {
+			select {
+			case <-collectCtx.Done():
+				return
+			case vec := <-vectorC:
+				keep, scenario, diags := d.decodeScenario(vec, sb.Block)
+				diagC <- diags
+				if keep {
+					scenarioC <- scenario
+				} else {
+					wg.Done()
+				}
+			}
+		}
+	}
+	for i := 0; i < runtime.NumCPU(); i++ {
+		go decodeScenario()
+	}
 
 	for i := range sb.Matrix.Vectors {
 		wg.Add(1)
-		go func(vec *Vector) {
-			defer wg.Done()
-			keep, scenario, diags := d.decodeScenario(vec, sb.Block)
-			diagC <- diags
-			if keep {
-				scenarioC <- scenario
-			}
-		}(sb.Matrix.Vectors[i])
+		vectorC <- sb.Matrix.Vectors[i]
 	}
 
 	wg.Wait()
diff --git a/internal/flightplan/scenario_decoder_test.go b/internal/flightplan/scenario_decoder_test.go
index d8aed4a..ecf2155 100644
--- a/internal/flightplan/scenario_decoder_test.go
+++ b/internal/flightplan/scenario_decoder_test.go
@@ -217,46 +217,46 @@ func Test_DecodedScenarioBlocks_CombinedMatrix(t *testing.T) {
 			in: DecodedScenarioBlocks{
 				{
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-						{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+						NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+						NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 					}},
 				},
 			},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 			}},
 		},
 		"multiple": {
 			in: DecodedScenarioBlocks{
 				{
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-						{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+						NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+						NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 					}},
 				},
 				{
 					Matrix: &Matrix{Vectors: []*Vector{
-						{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-						{elements: []Element{NewElement("backend", "postgres"), NewElement("arch", "aarch65")}},
-						{elements: []Element{NewElement("backend", "mysql"), NewElement("arch", "s309x")}},
+						NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+						NewVector(NewElement("backend", "postgres"), NewElement("arch", "aarch65")),
+						NewVector(NewElement("backend", "mysql"), NewElement("arch", "s309x")),
 					}},
 				},
 			},
 			expected: &Matrix{Vectors: []*Vector{
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-				{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
-				{elements: []Element{NewElement("backend", "postgres"), NewElement("arch", "aarch65")}},
-				{elements: []Element{NewElement("backend", "mysql"), NewElement("arch", "s309x")}},
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+				NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
+				NewVector(NewElement("backend", "postgres"), NewElement("arch", "aarch65")),
+				NewVector(NewElement("backend", "mysql"), NewElement("arch", "s309x")),
 			}},
 		},
 	} {
diff --git a/internal/flightplan/scenario_filter_test.go b/internal/flightplan/scenario_filter_test.go
index 13457b1..700207d 100644
--- a/internal/flightplan/scenario_filter_test.go
+++ b/internal/flightplan/scenario_filter_test.go
@@ -25,11 +25,8 @@ func Test_ScenarioFilter_WithScenarioFilterFromScenarioRef(t *testing.T) {
 		},
 	}
 	expected := &ScenarioFilter{
-		Name: "foo",
-		Include: &Vector{elements: []Element{
-			NewElement("backend", "raft"),
-			NewElement("cloud", "aws"),
-		}},
+		Name:    "foo",
+		Include: NewVector(NewElement("backend", "raft"), NewElement("cloud", "aws")),
 	}
 	sf, err := NewScenarioFilter(WithScenarioFilterFromScenarioRef(ref))
 	require.NoError(t, err)
@@ -67,7 +64,7 @@ func Test_ScenarioFilter_WithScenarioFilterFromSampleSubset(t *testing.T) {
 			},
 			expected: &ScenarioFilter{
 				Name:    "foo",
-				Include: &Vector{elements: []Element{NewElement("something", "other")}},
+				Include: NewVector(NewElement("something", "other")),
 			},
 		},
 		"scenario_name and scenario_filter are both defined and do not match": {
@@ -90,15 +87,15 @@ func Test_ScenarioFilter_WithScenarioFilterFromSampleSubset(t *testing.T) {
 			in: &SampleSubset{
 				Name: "foo",
 				Matrix: &Matrix{Vectors: []*Vector{
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
 				}},
 			},
 			expected: &ScenarioFilter{
 				Name: "foo",
 				IntersectionMatrix: &Matrix{Vectors: []*Vector{
-					{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-					{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
+					NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+					NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
 				}},
 			},
 		},
@@ -109,7 +106,7 @@ func Test_ScenarioFilter_WithScenarioFilterFromSampleSubset(t *testing.T) {
 			},
 			expected: &ScenarioFilter{
 				Name:    "foo",
-				Include: &Vector{elements: []Element{NewElement("backend", "raft")}},
+				Include: NewVector(NewElement("backend", "raft")),
 			},
 		},
 	} {
@@ -135,15 +132,15 @@ func Test_ScenarioFilter_Proto_RoundTrip(t *testing.T) {
 	expected := &ScenarioFilter{
 		Name:      "foo",
 		SelectAll: true,
-		Include:   &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("cloud", "aws")}},
+		Include:   NewVector(NewElement("backend", "raft"), NewElement("cloud", "aws")),
 		Exclude: []*Exclude{
-			{pb.Matrix_Exclude_MODE_CONTAINS, &Vector{elements: []Element{NewElement("cloud", "aws")}}},
+			{pb.Matrix_Exclude_MODE_CONTAINS, NewVector(NewElement("cloud", "aws"))},
 		},
 		IntersectionMatrix: &Matrix{Vectors: []*Vector{
-			{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}},
-			{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}},
-			{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}},
-			{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}},
+			NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64")),
+			NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64")),
+			NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64")),
+			NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64")),
 		}},
 	}
 	got := &ScenarioFilter{}
@@ -157,14 +154,14 @@ func Test_ScenarioFilter_ScenariosSelect(t *testing.T) {
 	t.Parallel()
 
 	scenarios := []*Scenario{
-		{Name: "fresh-install", Variants: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}}},
-		{Name: "fresh-install", Variants: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}}},
-		{Name: "fresh-install", Variants: &Vector{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}}},
-		{Name: "fresh-install", Variants: &Vector{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}}},
-		{Name: "upgrade", Variants: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64")}}},
-		{Name: "upgrade", Variants: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "amd64")}}},
-		{Name: "upgrade", Variants: &Vector{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "arm64")}}},
-		{Name: "upgrade", Variants: &Vector{elements: []Element{NewElement("backend", "consul"), NewElement("arch", "amd64")}}},
+		{Name: "fresh-install", Variants: NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"))},
+		{Name: "fresh-install", Variants: NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"))},
+		{Name: "fresh-install", Variants: NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"))},
+		{Name: "fresh-install", Variants: NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"))},
+		{Name: "upgrade", Variants: NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"))},
+		{Name: "upgrade", Variants: NewVector(NewElement("backend", "raft"), NewElement("arch", "amd64"))},
+		{Name: "upgrade", Variants: NewVector(NewElement("backend", "consul"), NewElement("arch", "arm64"))},
+		{Name: "upgrade", Variants: NewVector(NewElement("backend", "consul"), NewElement("arch", "amd64"))},
 		{Name: "no-variant"},
 	}
 
@@ -196,9 +193,9 @@ func Test_ScenarioFilter_ScenariosSelect(t *testing.T) {
 			"variant with no name",
 			scenarios,
 			&ScenarioFilter{
-				Include: &Vector{elements: []Element{NewElement("backend", "consul")}},
+				Include: NewVector(NewElement("backend", "consul")),
 				Exclude: []*Exclude{
-					{pb.Matrix_Exclude_MODE_CONTAINS, &Vector{elements: []Element{NewElement("arch", "arm64")}}},
+					{pb.Matrix_Exclude_MODE_CONTAINS, NewVector(NewElement("arch", "arm64"))},
 				},
 			},
 			[]*Scenario{scenarios[3], scenarios[7]},
@@ -208,9 +205,9 @@ func Test_ScenarioFilter_ScenariosSelect(t *testing.T) {
 			scenarios,
 			&ScenarioFilter{
 				Name:    "upgrade",
-				Include: &Vector{elements: []Element{NewElement("backend", "raft")}},
+				Include: NewVector(NewElement("backend", "raft")),
 				Exclude: []*Exclude{
-					{pb.Matrix_Exclude_MODE_CONTAINS, &Vector{elements: []Element{NewElement("arch", "amd64")}}},
+					{pb.Matrix_Exclude_MODE_CONTAINS, NewVector(NewElement("arch", "amd64"))},
 				},
 			},
 			[]*Scenario{scenarios[4]},
@@ -220,7 +217,7 @@ func Test_ScenarioFilter_ScenariosSelect(t *testing.T) {
 			scenarios,
 			&ScenarioFilter{
 				Name:    "upgrade",
-				Include: &Vector{elements: []Element{NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("edition", "ent")}},
+				Include: NewVector(NewElement("backend", "raft"), NewElement("arch", "arm64"), NewElement("edition", "ent")),
 			},
 			[]*Scenario{},
 		},
@@ -229,7 +226,7 @@ func Test_ScenarioFilter_ScenariosSelect(t *testing.T) {
 			scenarios,
 			&ScenarioFilter{
 				Name:    "no-variant",
-				Include: &Vector{elements: []Element{NewElement("backend", "raft")}},
+				Include: NewVector(NewElement("backend", "raft")),
 			},
 			[]*Scenario{},
 		},
@@ -279,9 +276,9 @@ func Test_ScenarioFilter_Parse(t *testing.T) {
 			[]string{"test", "backend:consul", "!arch:arm64"},
 			&ScenarioFilter{
 				Name:    "test",
-				Include: &Vector{elements: []Element{NewElement("backend", "consul")}},
+				Include: NewVector(NewElement("backend", "consul")),
 				Exclude: []*Exclude{
-					{pb.Matrix_Exclude_MODE_CONTAINS, &Vector{elements: []Element{NewElement("arch", "arm64")}}},
+					{pb.Matrix_Exclude_MODE_CONTAINS, NewVector(NewElement("arch", "arm64"))},
 				},
 			},
 		},
@@ -289,9 +286,9 @@ func Test_ScenarioFilter_Parse(t *testing.T) {
 			"filter with no name and variants",
 			[]string{"!arch:amd64", "backend:raft"},
 			&ScenarioFilter{
-				Include: &Vector{elements: []Element{NewElement("backend", "raft")}},
+				Include: NewVector(NewElement("backend", "raft")),
 				Exclude: []*Exclude{
-					{pb.Matrix_Exclude_MODE_CONTAINS, &Vector{elements: []Element{NewElement("arch", "amd64")}}},
+					{pb.Matrix_Exclude_MODE_CONTAINS, NewVector(NewElement("arch", "amd64"))},
 				},
 			},
 		},
diff --git a/internal/flightplan/scenario_step_test.go b/internal/flightplan/scenario_step_test.go
index fbcc451..6c53832 100644
--- a/internal/flightplan/scenario_step_test.go
+++ b/internal/flightplan/scenario_step_test.go
@@ -672,7 +672,7 @@ scenario "step_vars" {
 						Scenarios: []*Scenario{
 							{
 								Name:         "step_vars",
-								Variants:     &Vector{elements: []Element{{Key: "input", Val: "matrixinput"}}},
+								Variants:     NewVector(NewElement("input", "matrixinput")),
 								TerraformCLI: DefaultTerraformCLI(),
 								Steps: []*ScenarioStep{
 									{