diff --git a/internal/engine/experiment_integration_test.go b/internal/engine/experiment_integration_test.go
index 81aeb28e0..19179cb4a 100644
--- a/internal/engine/experiment_integration_test.go
+++ b/internal/engine/experiment_integration_test.go
@@ -285,8 +285,9 @@ func runexperimentflow(t *testing.T, experiment model.Experiment, input string)
 	if experiment.KibiBytesReceived() <= 0 {
 		t.Fatal("no data received?!")
 	}
-	if _, err := experiment.GetSummaryKeys(measurement); err != nil {
-		t.Fatal(err)
+	sk := experiment.GetSummaryKeys(measurement)
+	if sk == nil {
+		t.Fatal("got nil summary keys")
 	}
 }
 
diff --git a/internal/experiment/dash/measurer_test.go b/internal/experiment/dash/measurer_test.go
index c553d9cfa..f36450bca 100644
--- a/internal/experiment/dash/measurer_test.go
+++ b/internal/experiment/dash/measurer_test.go
@@ -105,22 +105,6 @@ func TestMeasureWithCancelledContext(t *testing.T) {
 	if !errors.Is(err, nil) {
 		t.Fatal("unexpected error value")
 	}
-	sk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
-}
-
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
 }
 
 func TestSummaryKeysGood(t *testing.T) {
@@ -129,12 +113,8 @@ func TestSummaryKeysGood(t *testing.T) {
 		MedianBitrate:   123,
 		MinPlayoutDelay: 12,
 	}}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
+	osk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*SummaryKeys)
 	if sk.Latency != 1234 {
 		t.Fatal("invalid latency")
 	}
@@ -147,4 +127,7 @@ func TestSummaryKeysGood(t *testing.T) {
 	if sk.IsAnomaly {
 		t.Fatal("invalid isAnomaly")
 	}
+	if sk.Anomaly() != sk.IsAnomaly {
+		t.Fatal("sk.Anomaly() does not return sk.IsAnomaly's value")
+	}
 }
diff --git a/internal/experiment/dnscheck/dnscheck_test.go b/internal/experiment/dnscheck/dnscheck_test.go
index a7fb9b336..aeb0e8eee 100644
--- a/internal/experiment/dnscheck/dnscheck_test.go
+++ b/internal/experiment/dnscheck/dnscheck_test.go
@@ -109,13 +109,6 @@ func TestWithCancelledContext(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestMakeResolverURL(t *testing.T) {
@@ -179,19 +172,6 @@ func newsession() model.ExperimentSession {
 	return &mockable.Session{MockableLogger: log.Log}
 }
 
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &TestKeys{}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
-
 func TestDNSCheckWait(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skip test in short mode")
diff --git a/internal/experiment/dnsping/dnsping_test.go b/internal/experiment/dnsping/dnsping_test.go
index 56c7efedb..4320b94a0 100644
--- a/internal/experiment/dnsping/dnsping_test.go
+++ b/internal/experiment/dnsping/dnsping_test.go
@@ -112,7 +112,7 @@ func TestMeasurer_run(t *testing.T) {
 		)
 
 		env.Do(func() {
-			meas, m, err := runHelper("udp://8.8.8.8:53")
+			meas, _, err := runHelper("udp://8.8.8.8:53")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
@@ -122,15 +122,6 @@ func TestMeasurer_run(t *testing.T) {
 				t.Fatal("unexpected number of pings", len(tk.Pings))
 			}
 
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.Query == nil {
 					t.Fatal("QUery should not be nil")
@@ -170,7 +161,7 @@ func TestMeasurer_run(t *testing.T) {
 		})
 
 		env.Do(func() {
-			meas, m, err := runHelper("udp://8.8.8.8:53")
+			meas, _, err := runHelper("udp://8.8.8.8:53")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
@@ -180,17 +171,6 @@ func TestMeasurer_run(t *testing.T) {
 				t.Fatal("unexpected number of pings", len(tk.Pings))
 			}
 
-			// note: this experiment does not set anomaly but we still want
-			// to have a test here for when we possibly will
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.Query == nil {
 					t.Fatal("QUery should not be nil")
diff --git a/internal/experiment/echcheck/measure_test.go b/internal/experiment/echcheck/measure_test.go
index 2ba09707e..2a53fbd93 100644
--- a/internal/experiment/echcheck/measure_test.go
+++ b/internal/experiment/echcheck/measure_test.go
@@ -113,13 +113,6 @@ func TestMeasurementSuccessRealWorld(t *testing.T) {
 	}
 
 	// check results
-	summary, err := measurer.GetSummaryKeys(&model.Measurement{})
-	if err != nil {
-		t.Fatal("unexpected error: ", err)
-	}
-	if summary.(SummaryKeys).IsAnomaly != false {
-		t.Fatal("expected false")
-	}
 	tk := msrmnt.TestKeys.(TestKeys)
 	if tk.Control.Failure != nil {
 		t.Fatal("unexpected control failure:", *tk.Control.Failure)
diff --git a/internal/experiment/example/example_test.go b/internal/experiment/example/example_test.go
index 6a9918347..b4a66aafc 100644
--- a/internal/experiment/example/example_test.go
+++ b/internal/experiment/example/example_test.go
@@ -35,13 +35,6 @@ func TestSuccess(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(example.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestFailure(t *testing.T) {
@@ -62,16 +55,3 @@ func TestFailure(t *testing.T) {
 		t.Fatal("expected an error here")
 	}
 }
-
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &example.TestKeys{}}
-	m := &example.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(example.SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
diff --git a/internal/experiment/fbmessenger/fbmessenger_test.go b/internal/experiment/fbmessenger/fbmessenger_test.go
index 5454923b3..1a1feae3f 100644
--- a/internal/experiment/fbmessenger/fbmessenger_test.go
+++ b/internal/experiment/fbmessenger/fbmessenger_test.go
@@ -180,13 +180,6 @@ func TestMeasurerRun(t *testing.T) {
 			if diff := cmp.Diff(expectAnalysis, tk.Analysis); diff != "" {
 				t.Fatal(diff)
 			}
-			sk, err := measurer.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if _, ok := sk.(fbmessenger.SummaryKeys); !ok {
-				t.Fatal("invalid type for summary keys")
-			}
 		})
 	})
 
@@ -393,23 +386,10 @@ func TestComputeEndpointStatsDNSIsLying(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &fbmessenger.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWithNils(t *testing.T) {
 	measurement := &model.Measurement{TestKeys: &fbmessenger.TestKeys{}}
-	m := &fbmessenger.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(fbmessenger.SummaryKeys)
+	osk := measurement.TestKeys.(*fbmessenger.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*fbmessenger.SummaryKeys)
 	if sk.DNSBlocking {
 		t.Fatal("invalid dnsBlocking")
 	}
@@ -428,12 +408,8 @@ func TestSummaryKeysWithFalseFalse(t *testing.T) {
 			FacebookDNSBlocking: &falseValue,
 		},
 	}}
-	m := &fbmessenger.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(fbmessenger.SummaryKeys)
+	osk := measurement.TestKeys.(*fbmessenger.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*fbmessenger.SummaryKeys)
 	if sk.DNSBlocking {
 		t.Fatal("invalid dnsBlocking")
 	}
@@ -452,12 +428,8 @@ func TestSummaryKeysWithFalseTrue(t *testing.T) {
 			FacebookDNSBlocking: &trueValue,
 		},
 	}}
-	m := &fbmessenger.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(fbmessenger.SummaryKeys)
+	osk := measurement.TestKeys.(*fbmessenger.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*fbmessenger.SummaryKeys)
 	if sk.DNSBlocking == false {
 		t.Fatal("invalid dnsBlocking")
 	}
@@ -476,12 +448,8 @@ func TestSummaryKeysWithTrueFalse(t *testing.T) {
 			FacebookDNSBlocking: &falseValue,
 		},
 	}}
-	m := &fbmessenger.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(fbmessenger.SummaryKeys)
+	osk := measurement.TestKeys.(*fbmessenger.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*fbmessenger.SummaryKeys)
 	if sk.DNSBlocking {
 		t.Fatal("invalid dnsBlocking")
 	}
@@ -500,12 +468,8 @@ func TestSummaryKeysWithTrueTrue(t *testing.T) {
 			FacebookDNSBlocking: &trueValue,
 		},
 	}}
-	m := &fbmessenger.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(fbmessenger.SummaryKeys)
+	osk := measurement.TestKeys.(*fbmessenger.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*fbmessenger.SummaryKeys)
 	if sk.DNSBlocking == false {
 		t.Fatal("invalid dnsBlocking")
 	}
diff --git a/internal/experiment/hhfm/hhfm_test.go b/internal/experiment/hhfm/hhfm_test.go
index eb420066d..05baa4a3d 100644
--- a/internal/experiment/hhfm/hhfm_test.go
+++ b/internal/experiment/hhfm/hhfm_test.go
@@ -258,13 +258,6 @@ func TestCancelledContext(t *testing.T) {
 	if tk.Tampering.Total != true {
 		t.Fatal("invalid Tampering.Total")
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(hhfm.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestNoHelpers(t *testing.T) {
@@ -863,15 +856,6 @@ func TestDialerDialContext(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &hhfm.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	tests := []struct {
 		tampering hhfm.Tampering
@@ -900,16 +884,11 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	}}
 	for idx, tt := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			m := &hhfm.Measurer{}
 			measurement := &model.Measurement{TestKeys: &hhfm.TestKeys{
 				Tampering: tt.tampering,
 			}}
-			got, err := m.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-				return
-			}
-			sk := got.(hhfm.SummaryKeys)
+			got := measurement.TestKeys.(*hhfm.TestKeys).MeasurementSummaryKeys()
+			sk := got.(*hhfm.SummaryKeys)
 			if sk.IsAnomaly != tt.isAnomaly {
 				t.Fatal("unexpected isAnomaly value")
 			}
diff --git a/internal/experiment/hirl/hirl_test.go b/internal/experiment/hirl/hirl_test.go
index 4a46f28c1..d34d783bb 100644
--- a/internal/experiment/hirl/hirl_test.go
+++ b/internal/experiment/hirl/hirl_test.go
@@ -141,13 +141,6 @@ func TestCancelledContext(t *testing.T) {
 	if tk.Tampering != false {
 		t.Fatal("overall there is tampering?!")
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(hirl.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 type FakeMethodSuccessful struct{}
@@ -602,25 +595,12 @@ func TestRunMethodReadEOFWithWrongData(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &hirl.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysFalse(t *testing.T) {
 	measurement := &model.Measurement{TestKeys: &hirl.TestKeys{
 		Tampering: false,
 	}}
-	m := &hirl.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(hirl.SummaryKeys)
+	osk := measurement.TestKeys.(*hirl.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*hirl.SummaryKeys)
 	if sk.IsAnomaly {
 		t.Fatal("invalid isAnomaly")
 	}
@@ -630,12 +610,8 @@ func TestSummaryKeysTrue(t *testing.T) {
 	measurement := &model.Measurement{TestKeys: &hirl.TestKeys{
 		Tampering: true,
 	}}
-	m := &hirl.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(hirl.SummaryKeys)
+	osk := measurement.TestKeys.(*hirl.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*hirl.SummaryKeys)
 	if sk.IsAnomaly == false {
 		t.Fatal("invalid isAnomaly")
 	}
diff --git a/internal/experiment/httphostheader/httphostheader_test.go b/internal/experiment/httphostheader/httphostheader_test.go
index dd7a6c036..82b7ce2a4 100644
--- a/internal/experiment/httphostheader/httphostheader_test.go
+++ b/internal/experiment/httphostheader/httphostheader_test.go
@@ -53,13 +53,6 @@ func TestMeasurerMeasureNoTestHelper(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestRunnerHTTPSetHostHeader(t *testing.T) {
@@ -92,16 +85,3 @@ func TestRunnerHTTPSetHostHeader(t *testing.T) {
 func newsession() model.ExperimentSession {
 	return &mockable.Session{MockableLogger: log.Log}
 }
-
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &TestKeys{}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
diff --git a/internal/experiment/ndt7/ndt7_test.go b/internal/experiment/ndt7/ndt7_test.go
index 371a28957..a1d710c58 100644
--- a/internal/experiment/ndt7/ndt7_test.go
+++ b/internal/experiment/ndt7/ndt7_test.go
@@ -121,13 +121,6 @@ func TestGood(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestFailDownload(t *testing.T) {
@@ -227,15 +220,6 @@ func TestDownloadJSONUnmarshalFail(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysGood(t *testing.T) {
 	measurement := &model.Measurement{TestKeys: &TestKeys{Summary: Summary{
 		RetransmitRate: 1,
@@ -247,12 +231,8 @@ func TestSummaryKeysGood(t *testing.T) {
 		Download:       7,
 		Upload:         8,
 	}}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
+	osk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*SummaryKeys)
 	if sk.RetransmitRate != 1 {
 		t.Fatal("invalid retransmitRate")
 	}
diff --git a/internal/experiment/portfiltering/measurer_test.go b/internal/experiment/portfiltering/measurer_test.go
index 81eeb6956..465cc9d0c 100644
--- a/internal/experiment/portfiltering/measurer_test.go
+++ b/internal/experiment/portfiltering/measurer_test.go
@@ -42,12 +42,4 @@ func TestMeasurer_run(t *testing.T) {
 	if len(tk.TCPConnect) != len(Ports) {
 		t.Fatal("unexpected number of ports")
 	}
-	ask, err := m.GetSummaryKeys(meas)
-	if err != nil {
-		t.Fatal("cannot obtain summary")
-	}
-	summary := ask.(SummaryKeys)
-	if summary.IsAnomaly {
-		t.Fatal("expected no anomaly")
-	}
 }
diff --git a/internal/experiment/psiphon/psiphon_test.go b/internal/experiment/psiphon/psiphon_test.go
index 28f8e0d89..3125fdeee 100644
--- a/internal/experiment/psiphon/psiphon_test.go
+++ b/internal/experiment/psiphon/psiphon_test.go
@@ -46,13 +46,6 @@ func TestRunWithCancelledContext(t *testing.T) {
 	if tk.MaxRuntime <= 0 {
 		t.Fatal("you did not set the max runtime")
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(psiphon.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestRunWithCustomInputAndCancelledContext(t *testing.T) {
@@ -122,25 +115,12 @@ func newfakesession() model.ExperimentSession {
 	return &mockable.Session{MockableLogger: log.Log}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &psiphon.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysGood(t *testing.T) {
 	measurement := &model.Measurement{TestKeys: &psiphon.TestKeys{TestKeys: urlgetter.TestKeys{
 		BootstrapTime: 123,
 	}}}
-	m := &psiphon.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(psiphon.SummaryKeys)
+	osk := measurement.TestKeys.(*psiphon.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*psiphon.SummaryKeys)
 	if sk.BootstrapTime != 123 {
 		t.Fatal("invalid latency")
 	}
@@ -158,12 +138,8 @@ func TestSummaryKeysFailure(t *testing.T) {
 		BootstrapTime: 123,
 		Failure:       &expected,
 	}}}
-	m := &psiphon.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(psiphon.SummaryKeys)
+	osk := measurement.TestKeys.(*psiphon.TestKeys).MeasurementSummaryKeys()
+	sk := osk.(*psiphon.SummaryKeys)
 	if sk.BootstrapTime != 123 {
 		t.Fatal("invalid latency")
 	}
diff --git a/internal/experiment/quicping/quicping_test.go b/internal/experiment/quicping/quicping_test.go
index c8705e65c..37e72ff45 100644
--- a/internal/experiment/quicping/quicping_test.go
+++ b/internal/experiment/quicping/quicping_test.go
@@ -113,13 +113,6 @@ func TestSuccess(t *testing.T) {
 			}
 		}
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestWithCancelledContext(t *testing.T) {
diff --git a/internal/experiment/riseupvpn/riseupvpn_test.go b/internal/experiment/riseupvpn/riseupvpn_test.go
index 9370aeb75..f52a0fe8a 100644
--- a/internal/experiment/riseupvpn/riseupvpn_test.go
+++ b/internal/experiment/riseupvpn/riseupvpn_test.go
@@ -495,18 +495,6 @@ func TestFailureGateway1TransportNOK(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysAlwaysReturnIsAnomalyFalse(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &riseupvpn.Measurer{}
-	result, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal("GetSummaryKeys should never return an error")
-	}
-	if result.(riseupvpn.SummaryKeys).IsAnomaly {
-		t.Fatal("GetSummaryKeys should never return IsAnomaly true")
-	}
-}
-
 func generateMockGetter(requestResponse map[string]string, responseStatus map[string]bool) urlgetter.MultiGetter {
 	return func(ctx context.Context, g urlgetter.Getter) (urlgetter.TestKeys, error) {
 		url := g.Target
diff --git a/internal/experiment/signal/signal_test.go b/internal/experiment/signal/signal_test.go
index 4170b98d3..5dcbf892f 100644
--- a/internal/experiment/signal/signal_test.go
+++ b/internal/experiment/signal/signal_test.go
@@ -72,13 +72,6 @@ func TestGood(t *testing.T) {
 	if tk.SignalBackendStatus != "ok" {
 		t.Fatal("unexpected SignalBackendStatus")
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(signal.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestUpdate(t *testing.T) {
@@ -120,15 +113,3 @@ func TestBadSignalCA(t *testing.T) {
 		t.Fatal("not the error we expected")
 	}
 }
-
-func TestGetSummaryInvalidType(t *testing.T) {
-	measurer := signal.Measurer{}
-	in := make(chan int)
-	out, err := measurer.GetSummaryKeys(&model.Measurement{TestKeys: in})
-	if err == nil || err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected", err)
-	}
-	if out != nil {
-		t.Fatal("expected nil output here")
-	}
-}
diff --git a/internal/experiment/simplequicping/simplequicping_test.go b/internal/experiment/simplequicping/simplequicping_test.go
index 156b8e73e..ffdc0764e 100644
--- a/internal/experiment/simplequicping/simplequicping_test.go
+++ b/internal/experiment/simplequicping/simplequicping_test.go
@@ -116,20 +116,11 @@ func TestMeasurerRun(t *testing.T) {
 		defer env.Close()
 
 		env.Do(func() {
-			meas, m, err := runHelper("quichandshake://8.8.8.8:443")
+			meas, _, err := runHelper("quichandshake://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
 
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			tk, _ := (meas.TestKeys).(*TestKeys)
 			if len(tk.Pings) != NPINGS {
 				t.Fatal("unexpected number of pings")
@@ -169,24 +160,13 @@ func TestMeasurerRun(t *testing.T) {
 		})
 
 		env.Do(func() {
-			meas, m, err := runHelper("quichandshake://8.8.8.8:443")
+			meas, _, err := runHelper("quichandshake://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
 
 			tk, _ := (meas.TestKeys).(*TestKeys)
 
-			// note: this experiment does not set anomaly but we still want
-			// to have a test here for when we possibly will
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.QUICHandshake.Failure == nil {
 					t.Fatal("expected failure here but found nil")
diff --git a/internal/experiment/sniblocking/sniblocking_test.go b/internal/experiment/sniblocking/sniblocking_test.go
index cf8e614fe..0519ba062 100644
--- a/internal/experiment/sniblocking/sniblocking_test.go
+++ b/internal/experiment/sniblocking/sniblocking_test.go
@@ -185,19 +185,6 @@ func TestMaybeURLToSNI(t *testing.T) {
 	})
 }
 
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &TestKeys{}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
-
 // exampleOrgAddr is the IP address used for example.org in netem-based nettests.
 const exampleOrgAddr = "93.184.216.34"
 
@@ -379,13 +366,6 @@ func TestMeasurerRun(t *testing.T) {
 		if tk.Result != classAnomalyUnexpectedFailure {
 			t.Fatalf("Unexpected result, expected: %s, got: %s", classAnomalyUnexpectedFailure, tk.Result)
 		}
-		sk, err := measurer.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, ok := sk.(SummaryKeys); !ok {
-			t.Fatal("invalid type for summary keys")
-		}
 		target := tk.Target
 		if target.Agent != "" {
 			t.Fatal("not the expected Agent")
diff --git a/internal/experiment/stunreachability/stunreachability_test.go b/internal/experiment/stunreachability/stunreachability_test.go
index 8336584aa..4abecbdfd 100644
--- a/internal/experiment/stunreachability/stunreachability_test.go
+++ b/internal/experiment/stunreachability/stunreachability_test.go
@@ -152,13 +152,6 @@ func TestCancelledContext(t *testing.T) {
 	if len(tk.Queries) <= 0 {
 		t.Fatal("no DNS queries?!")
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestNewClientFailure(t *testing.T) {
@@ -276,16 +269,3 @@ func TestReadFailure(t *testing.T) {
 		t.Fatal("DNS queries?!")
 	}
 }
-
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &TestKeys{}}
-	m := &Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
diff --git a/internal/experiment/tcpping/tcpping_test.go b/internal/experiment/tcpping/tcpping_test.go
index 1d3bddffc..ebe197a7d 100644
--- a/internal/experiment/tcpping/tcpping_test.go
+++ b/internal/experiment/tcpping/tcpping_test.go
@@ -102,7 +102,7 @@ func TestMeasurer_run(t *testing.T) {
 		defer env.Close()
 
 		env.Do(func() {
-			meas, m, err := runHelper("tcpconnect://8.8.8.8:443")
+			meas, _, err := runHelper("tcpconnect://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
@@ -112,15 +112,6 @@ func TestMeasurer_run(t *testing.T) {
 				t.Fatal("unexpected number of pings")
 			}
 
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.TCPConnect == nil {
 					t.Fatal("TCPConnect should not be nil")
@@ -161,24 +152,13 @@ func TestMeasurer_run(t *testing.T) {
 		})
 
 		env.Do(func() {
-			meas, m, err := runHelper("tcpconnect://8.8.8.8:443")
+			meas, _, err := runHelper("tcpconnect://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
 
 			tk, _ := (meas.TestKeys).(*TestKeys)
 
-			// note: this experiment does not set anomaly but we still want
-			// to have a test here for when we possibly will
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.TCPConnect == nil {
 					t.Fatal("TCPConnect should not be nil")
diff --git a/internal/experiment/telegram/telegram_test.go b/internal/experiment/telegram/telegram_test.go
index ed1ed43cc..81ae6a5db 100644
--- a/internal/experiment/telegram/telegram_test.go
+++ b/internal/experiment/telegram/telegram_test.go
@@ -219,15 +219,6 @@ func TestUpdateWithAllGood(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &telegram.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	failure := io.EOF.Error()
 	tests := []struct {
@@ -248,14 +239,9 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	}}
 	for idx, tt := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			m := &telegram.Measurer{}
 			measurement := &model.Measurement{TestKeys: &tt.tk}
-			got, err := m.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-				return
-			}
-			sk := got.(telegram.SummaryKeys)
+			got := measurement.TestKeys.(*telegram.TestKeys).MeasurementSummaryKeys()
+			sk := got.(*telegram.SummaryKeys)
 			if sk.IsAnomaly != tt.isAnomaly {
 				t.Fatal("unexpected isAnomaly value")
 			}
@@ -374,13 +360,6 @@ func TestMeasurerRun(t *testing.T) {
 			if tk.TelegramWebStatus != "ok" {
 				t.Fatal("unexpected TelegramWebStatus")
 			}
-			sk, err := measurer.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if _, ok := sk.(telegram.SummaryKeys); !ok {
-				t.Fatal("invalid type for summary keys")
-			}
 		})
 	})
 
diff --git a/internal/experiment/tlsmiddlebox/measurer_test.go b/internal/experiment/tlsmiddlebox/measurer_test.go
index dadd78f37..8c21e8359 100644
--- a/internal/experiment/tlsmiddlebox/measurer_test.go
+++ b/internal/experiment/tlsmiddlebox/measurer_test.go
@@ -95,18 +95,10 @@ func TestMeasurer_input_failure(t *testing.T) {
 			t.Fatal(err)
 		}
 		URL.Scheme = "tlshandshake"
-		meas, m, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
+		meas, _, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
 		if err != nil {
 			t.Fatal(err)
 		}
-		ask, err := m.GetSummaryKeys(meas)
-		if err != nil {
-			t.Fatal("cannot obtain summary")
-		}
-		summary := ask.(SummaryKeys)
-		if summary.IsAnomaly {
-			t.Fatal("expected no anomaly")
-		}
 
 		t.Run("testkeys", func(t *testing.T) {
 			tk := meas.TestKeys.(*TestKeys)
@@ -150,18 +142,10 @@ func TestMeasurer_input_failure(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		meas, m, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
+		meas, _, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
 		if err != nil {
 			t.Fatal(err)
 		}
-		ask, err := m.GetSummaryKeys(meas)
-		if err != nil {
-			t.Fatal("cannot obtain summary")
-		}
-		summary := ask.(SummaryKeys)
-		if summary.IsAnomaly {
-			t.Fatal("expected no anomaly")
-		}
 
 		t.Run("testkeys", func(t *testing.T) {
 			tk := meas.TestKeys.(*TestKeys)
@@ -205,18 +189,10 @@ func TestMeasurer_input_failure(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		meas, m, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
+		meas, _, err := runHelper(context.Background(), "tlstrace://google.com", URL.String(), "")
 		if err != nil {
 			t.Fatal(err)
 		}
-		ask, err := m.GetSummaryKeys(meas)
-		if err != nil {
-			t.Fatal("cannot obtain summary")
-		}
-		summary := ask.(SummaryKeys)
-		if summary.IsAnomaly {
-			t.Fatal("expected no anomaly")
-		}
 
 		t.Run("testkeys", func(t *testing.T) {
 			tk := meas.TestKeys.(*TestKeys)
diff --git a/internal/experiment/tlsping/tlsping_test.go b/internal/experiment/tlsping/tlsping_test.go
index 8c7cc0fe6..f0d4d7a2c 100644
--- a/internal/experiment/tlsping/tlsping_test.go
+++ b/internal/experiment/tlsping/tlsping_test.go
@@ -117,7 +117,7 @@ func TestMeasurerRun(t *testing.T) {
 		defer env.Close()
 
 		env.Do(func() {
-			meas, m, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
+			meas, _, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
@@ -127,15 +127,6 @@ func TestMeasurerRun(t *testing.T) {
 				t.Fatal("unexpected number of pings")
 			}
 
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.TCPConnect == nil {
 					t.Fatal("TCPConnect should not be nil")
@@ -176,24 +167,13 @@ func TestMeasurerRun(t *testing.T) {
 		})
 
 		env.Do(func() {
-			meas, m, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
+			meas, _, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
 
 			tk, _ := (meas.TestKeys).(*TestKeys)
 
-			// note: this experiment does not set anomaly but we still want
-			// to have a test here for when we possibly will
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.TCPConnect == nil {
 					t.Fatal("TCPConnect should not be nil")
@@ -240,23 +220,12 @@ func TestMeasurerRun(t *testing.T) {
 		})
 
 		env.Do(func() {
-			meas, m, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
+			meas, _, err := runHelper(context.Background(), "tlshandshake://8.8.8.8:443")
 			if err != nil {
 				t.Fatalf("Unexpected error: %s", err)
 			}
 			tk, _ := (meas.TestKeys).(*TestKeys)
 
-			// note: this experiment does not set anomaly but we still want
-			// to have a test here for when we possibly will
-			ask, err := m.GetSummaryKeys(meas)
-			if err != nil {
-				t.Fatal("cannot obtain summary")
-			}
-			summary := ask.(SummaryKeys)
-			if summary.IsAnomaly {
-				t.Fatal("expected no anomaly")
-			}
-
 			for _, p := range tk.Pings {
 				if p.TCPConnect == nil {
 					t.Fatal("TCPConnect should not be nil")
diff --git a/internal/experiment/tlstool/tlstool_test.go b/internal/experiment/tlstool/tlstool_test.go
index c2d96b9a6..7e9c56d7f 100644
--- a/internal/experiment/tlstool/tlstool_test.go
+++ b/internal/experiment/tlstool/tlstool_test.go
@@ -69,24 +69,4 @@ func TestRunWithCancelledContext(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(tlstool.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
-}
-
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &tlstool.TestKeys{}}
-	m := &tlstool.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(tlstool.SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
 }
diff --git a/internal/experiment/tor/tor_test.go b/internal/experiment/tor/tor_test.go
index db0e7018e..a5e54e3db 100644
--- a/internal/experiment/tor/tor_test.go
+++ b/internal/experiment/tor/tor_test.go
@@ -108,13 +108,6 @@ func TestMeasurerMeasureGood(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 var staticPrivateTestingTargetEndpoint = "209.148.46.65:443"
@@ -736,15 +729,6 @@ func TestMaybeScrubbingLogger(t *testing.T) {
 	})
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	tests := []struct {
 		tk        TestKeys
@@ -779,14 +763,9 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	}}
 	for idx, tt := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			m := &Measurer{}
 			measurement := &model.Measurement{TestKeys: &tt.tk}
-			got, err := m.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-				return
-			}
-			sk := got.(SummaryKeys)
+			got := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+			sk := got.(*SummaryKeys)
 			if sk.IsAnomaly != tt.isAnomaly {
 				t.Fatal("unexpected isAnomaly value")
 			}
diff --git a/internal/experiment/torsf/torsf_test.go b/internal/experiment/torsf/torsf_test.go
index 120ae8649..a8d2dc59c 100644
--- a/internal/experiment/torsf/torsf_test.go
+++ b/internal/experiment/torsf/torsf_test.go
@@ -412,52 +412,14 @@ func TestBaseTunnelDir(t *testing.T) {
 }
 
 func TestGetSummaryKeys(t *testing.T) {
-	t.Run("in case of untyped nil TestKeys", func(t *testing.T) {
-		measurement := &model.Measurement{
-			TestKeys: nil,
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errInvalidTestKeysType) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
-	t.Run("in case of typed nil TestKeys", func(t *testing.T) {
-		var tk *TestKeys
-		measurement := &model.Measurement{
-			TestKeys: tk,
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errNilTestKeys) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
-	t.Run("in case of invalid TestKeys type", func(t *testing.T) {
-		measurement := &model.Measurement{
-			TestKeys: make(chan int),
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errInvalidTestKeysType) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
 	t.Run("in case of success", func(t *testing.T) {
 		measurement := &model.Measurement{
 			TestKeys: &TestKeys{
 				Failure: nil,
 			},
 		}
-		m := &Measurer{}
-		sk, err := m.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		rsk := sk.(SummaryKeys)
+		sk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+		rsk := sk.(*SummaryKeys)
 		if rsk.IsAnomaly {
 			t.Fatal("expected no anomaly here")
 		}
@@ -470,12 +432,8 @@ func TestGetSummaryKeys(t *testing.T) {
 				Failure: &failure,
 			},
 		}
-		m := &Measurer{}
-		sk, err := m.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		rsk := sk.(SummaryKeys)
+		sk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+		rsk := sk.(*SummaryKeys)
 		if !rsk.IsAnomaly {
 			t.Fatal("expected anomaly here")
 		}
diff --git a/internal/experiment/urlgetter/urlgetter_test.go b/internal/experiment/urlgetter/urlgetter_test.go
index 1fbd44dde..cb1117983 100644
--- a/internal/experiment/urlgetter/urlgetter_test.go
+++ b/internal/experiment/urlgetter/urlgetter_test.go
@@ -39,13 +39,6 @@ func TestMeasurer(t *testing.T) {
 	if len(tk.DNSCache) != 0 {
 		t.Fatal("not the DNSCache value we expected")
 	}
-	sk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(urlgetter.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestMeasurerDNSCache(t *testing.T) {
@@ -79,16 +72,3 @@ func TestMeasurerDNSCache(t *testing.T) {
 		t.Fatal("invalid tk.DNSCache")
 	}
 }
-
-func TestSummaryKeysGeneric(t *testing.T) {
-	measurement := &model.Measurement{TestKeys: &urlgetter.TestKeys{}}
-	m := &urlgetter.Measurer{}
-	osk, err := m.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sk := osk.(urlgetter.SummaryKeys)
-	if sk.IsAnomaly {
-		t.Fatal("invalid isAnomaly")
-	}
-}
diff --git a/internal/experiment/vanillator/vanillator_test.go b/internal/experiment/vanillator/vanillator_test.go
index c6c075f53..434ebea05 100644
--- a/internal/experiment/vanillator/vanillator_test.go
+++ b/internal/experiment/vanillator/vanillator_test.go
@@ -295,52 +295,14 @@ func TestFailureNoTorBinary(t *testing.T) {
 }
 
 func TestGetSummaryKeys(t *testing.T) {
-	t.Run("in case of untyped nil TestKeys", func(t *testing.T) {
-		measurement := &model.Measurement{
-			TestKeys: nil,
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errInvalidTestKeysType) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
-	t.Run("in case of typed nil TestKeys", func(t *testing.T) {
-		var tk *TestKeys
-		measurement := &model.Measurement{
-			TestKeys: tk,
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errNilTestKeys) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
-	t.Run("in case of invalid TestKeys type", func(t *testing.T) {
-		measurement := &model.Measurement{
-			TestKeys: make(chan int),
-		}
-		m := &Measurer{}
-		_, err := m.GetSummaryKeys(measurement)
-		if !errors.Is(err, errInvalidTestKeysType) {
-			t.Fatal("unexpected error", err)
-		}
-	})
-
 	t.Run("in case of success", func(t *testing.T) {
 		measurement := &model.Measurement{
 			TestKeys: &TestKeys{
 				Failure: nil,
 			},
 		}
-		m := &Measurer{}
-		sk, err := m.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		rsk := sk.(SummaryKeys)
+		sk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+		rsk := sk.(*SummaryKeys)
 		if rsk.IsAnomaly {
 			t.Fatal("expected no anomaly here")
 		}
@@ -353,12 +315,8 @@ func TestGetSummaryKeys(t *testing.T) {
 				Failure: &failure,
 			},
 		}
-		m := &Measurer{}
-		sk, err := m.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		rsk := sk.(SummaryKeys)
+		sk := measurement.TestKeys.(*TestKeys).MeasurementSummaryKeys()
+		rsk := sk.(*SummaryKeys)
 		if !rsk.IsAnomaly {
 			t.Fatal("expected anomaly here")
 		}
diff --git a/internal/experiment/webconnectivity/webconnectivity_test.go b/internal/experiment/webconnectivity/webconnectivity_test.go
index fad9fe82f..690b6ceef 100644
--- a/internal/experiment/webconnectivity/webconnectivity_test.go
+++ b/internal/experiment/webconnectivity/webconnectivity_test.go
@@ -88,14 +88,6 @@ func TestMeasureWithCancelledContext(t *testing.T) {
 	if tk.HTTPExperimentFailure != nil {
 		t.Fatal("unexpected http_experiment_failure")
 	}
-	// TODO(bassosimone): write further checks here?
-	sk, err := measurer.GetSummaryKeys(measurement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := sk.(webconnectivity.SummaryKeys); !ok {
-		t.Fatal("invalid type for summary keys")
-	}
 }
 
 func TestMeasureWithNoInput(t *testing.T) {
@@ -385,15 +377,6 @@ func TestComputeTCPBlocking(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &webconnectivity.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	failure := io.EOF.Error()
 	truy := true
@@ -424,14 +407,9 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	}}
 	for idx, tt := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			m := &webconnectivity.Measurer{}
 			measurement := &model.Measurement{TestKeys: &tt.tk}
-			got, err := m.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-				return
-			}
-			sk := got.(webconnectivity.SummaryKeys)
+			got := measurement.TestKeys.(*webconnectivity.TestKeys).MeasurementSummaryKeys()
+			sk := got.(*webconnectivity.SummaryKeys)
 			if sk.IsAnomaly != tt.isAnomaly {
 				t.Fatal("unexpected isAnomaly value")
 			}
diff --git a/internal/experiment/whatsapp/whatsapp_test.go b/internal/experiment/whatsapp/whatsapp_test.go
index 7f32b08ed..50115f82a 100644
--- a/internal/experiment/whatsapp/whatsapp_test.go
+++ b/internal/experiment/whatsapp/whatsapp_test.go
@@ -286,13 +286,6 @@ func TestFailureAllEndpoints(t *testing.T) {
 		if tk.WhatsappWebStatus != "blocked" {
 			t.Fatal("invalid WhatsappWebStatus")
 		}
-		sk, err := measurer.GetSummaryKeys(measurement)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, ok := sk.(whatsapp.SummaryKeys); !ok {
-			t.Fatal("invalid type for summary keys")
-		}
 	})
 }
 
@@ -561,15 +554,6 @@ func TestWeConfigureWebChecksCorrectly(t *testing.T) {
 	}
 }
 
-func TestSummaryKeysInvalidType(t *testing.T) {
-	measurement := new(model.Measurement)
-	m := &whatsapp.Measurer{}
-	_, err := m.GetSummaryKeys(measurement)
-	if err.Error() != "invalid test keys type" {
-		t.Fatal("not the error we expected")
-	}
-}
-
 func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	tests := []struct {
 		tk                         whatsapp.TestKeys
@@ -610,14 +594,9 @@ func TestSummaryKeysWorksAsIntended(t *testing.T) {
 	}}
 	for idx, tt := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			m := &whatsapp.Measurer{}
 			measurement := &model.Measurement{TestKeys: &tt.tk}
-			got, err := m.GetSummaryKeys(measurement)
-			if err != nil {
-				t.Fatal(err)
-				return
-			}
-			sk := got.(whatsapp.SummaryKeys)
+			got := measurement.TestKeys.(*whatsapp.TestKeys).MeasurementSummaryKeys()
+			sk := got.(*whatsapp.SummaryKeys)
 			if sk.IsAnomaly != tt.isAnomaly {
 				t.Fatal("unexpected isAnomaly value")
 			}
diff --git a/internal/mocks/database.go b/internal/mocks/database.go
index 0a59b9fd3..834bd383e 100644
--- a/internal/mocks/database.go
+++ b/internal/mocks/database.go
@@ -16,7 +16,7 @@ type Database struct {
 	MockDeleteResult         func(resultID int64) error
 	MockCreateMeasurement    func(reportID sql.NullString, testName string, measurementDir string,
 		idx int, resultID int64, urlID sql.NullInt64) (*model.DatabaseMeasurement, error)
-	MockAddTestKeys        func(msmt *model.DatabaseMeasurement, tk interface{}) error
+	MockAddTestKeys        func(msmt *model.DatabaseMeasurement, sk model.MeasurementSummaryKeys) error
 	MockDone               func(msmt *model.DatabaseMeasurement) error
 	MockUploadFailed       func(msmt *model.DatabaseMeasurement, failure string) error
 	MockUploadSucceeded    func(msmt *model.DatabaseMeasurement) error
@@ -65,8 +65,8 @@ func (d *Database) CreateMeasurement(reportID sql.NullString, testName string, m
 }
 
 // AddTestKeys calls MockAddTestKeys
-func (d *Database) AddTestKeys(msmt *model.DatabaseMeasurement, tk interface{}) error {
-	return d.MockAddTestKeys(msmt, tk)
+func (d *Database) AddTestKeys(msmt *model.DatabaseMeasurement, sk model.MeasurementSummaryKeys) error {
+	return d.MockAddTestKeys(msmt, sk)
 }
 
 // Done calls MockDone
diff --git a/internal/mocks/database_test.go b/internal/mocks/database_test.go
index c35f23fdf..13bd47a24 100644
--- a/internal/mocks/database_test.go
+++ b/internal/mocks/database_test.go
@@ -119,12 +119,11 @@ func TestDatabase(t *testing.T) {
 	t.Run("AddTestKeys", func(t *testing.T) {
 		expected := errors.New("mocked")
 		db := &Database{
-			MockAddTestKeys: func(msmt *model.DatabaseMeasurement, tk interface{}) error {
+			MockAddTestKeys: func(msmt *model.DatabaseMeasurement, sk model.MeasurementSummaryKeys) error {
 				return expected
 			},
 		}
-		tk := make(map[string]string) // use a random type to pass as any in test keys
-		err := db.AddTestKeys(&model.DatabaseMeasurement{}, tk)
+		err := db.AddTestKeys(&model.DatabaseMeasurement{}, nil /* it's fine because we don't use it in the func above */)
 		if !errors.Is(err, expected) {
 			t.Fatal("not the error we expected")
 		}
diff --git a/internal/mocks/experiment.go b/internal/mocks/experiment.go
index bf8c1f49d..346e2ef6f 100644
--- a/internal/mocks/experiment.go
+++ b/internal/mocks/experiment.go
@@ -14,7 +14,7 @@ type Experiment struct {
 
 	MockName func() string
 
-	MockGetSummaryKeys func(m *model.Measurement) (any, error)
+	MockGetSummaryKeys func(m *model.Measurement) model.MeasurementSummaryKeys
 
 	MockReportID func() string
 
@@ -43,7 +43,7 @@ func (e *Experiment) Name() string {
 	return e.MockName()
 }
 
-func (e *Experiment) GetSummaryKeys(m *model.Measurement) (any, error) {
+func (e *Experiment) GetSummaryKeys(m *model.Measurement) model.MeasurementSummaryKeys {
 	return e.MockGetSummaryKeys(m)
 }
 
diff --git a/internal/mocks/experiment_test.go b/internal/mocks/experiment_test.go
index bb16b1553..c94c7dcaf 100644
--- a/internal/mocks/experiment_test.go
+++ b/internal/mocks/experiment_test.go
@@ -46,16 +46,12 @@ func TestExperiment(t *testing.T) {
 	})
 
 	t.Run("GetSummaryKeys", func(t *testing.T) {
-		expected := errors.New("mocked err")
 		e := &Experiment{
-			MockGetSummaryKeys: func(m *model.Measurement) (any, error) {
-				return nil, expected
+			MockGetSummaryKeys: func(m *model.Measurement) model.MeasurementSummaryKeys {
+				return nil
 			},
 		}
-		out, err := e.GetSummaryKeys(&model.Measurement{})
-		if !errors.Is(err, expected) {
-			t.Fatal("unexpected err", err)
-		}
+		out := e.GetSummaryKeys(&model.Measurement{})
 		if out != nil {
 			t.Fatal("invalid out")
 		}