diff --git a/docs/site/content/en/docs/Tasks/import-export/index.md b/docs/site/content/en/docs/Tasks/import-export/index.md
new file mode 100644
index 000000000..00a690234
--- /dev/null
+++ b/docs/site/content/en/docs/Tasks/import-export/index.md
@@ -0,0 +1,64 @@
+---
+title: Import and Export Tests and Schemas
+date: 2023-11-30
+description: How to import and export Tests and Schemas in Horreum
+categories: [Tutorial]
+weight: 3
+---
+
+> **Prerequisites**:
+
+> 1. Horreum is running
+> 2. To export you have previously defined a `Schema` for the JSON data you wish to analyze, please see [Define a Schema](/docs/tasks/define-schema-and-views/)
+> 3. To export you have previously defined a Test, please see [Create new Test](/docs/tasks/create-new-test/)
+
+## Background
+
+To simplify copying [Tests](https://horreum.hyperfoil.io/docs/concepts/core-concepts/#test) and [Schemas](https://horreum.hyperfoil.io/docs/concepts/core-concepts/#schema) between Horreum instances Horreum provides a simple API to export and import new Tests and Schemas. Horreum also support updating exising Schemas and Tests by importing Tests or Schemas with existing Id's.
+
+## TestExport
+
+The export object for Tests is called [TestExport](https://horreum.hyperfoil.io/openapi/#tag/Test/operation/importTest) and contains a lot of other fields in addition to what's defined in [Test](https://horreum.hyperfoil.io/docs/concepts/core-concepts/#test). This includes, variables, experiments, actions, subscriptions, datastore and missingDataRules. This is to simplify the import/export experience and make sure that all the data related to a Test has a single entrypoint with regards to import and export. Note that secrets defined on [Action](https://horreum.hyperfoil.io/docs/tasks/configure-actions/) are not portable between Horreum instances and there might be security concerns so they are omitted. The apiKey and password attributs defined on the config field in [Datastore](https://horreum.hyperfoil.io/docs/integrations/) are also omitted and will have to be manually added in a separate step.
+
+## TestSchema
+
+The export object for Schemas is called [SchemaExport](https://horreum.hyperfoil.io/openapi/#tag/Schema/operation/importSchema) and contains other fields in addition to what's defined in [Schema](https://horreum.hyperfoil.io/docs/concepts/core-concepts/#schema). This includes, labels, extractors and transformers. This is to simplify the import/export experience and make sure that all the data related to a Schema has a single entrypoint with regards to import and export.
+
+## Import Schemas
+
+```bash
+curl 'http://localhost:8080/api/schema/import/' \
+    -s -X POST -H 'content-type: application/json' \
+    -H 'Authorization: Bearer '$TOKEN \
+    -d @/path/to/schema.json
+```
+
+If you are unfamiliar with creating the auth token please see [Upload Run](/docs/tasks/upload-new-run/).
+
+## Import Tests
+
+```bash
+curl 'http://localhost:8080/api/test/import/' \
+    -s -X POST -H 'content-type: application/json' \
+    -H 'Authorization: Bearer '$TOKEN \
+    -d @/path/to/test.json
+```
+
+## Export Schemas
+
+```bash
+SCHEMAID='123'
+curl 'http://localhost:8080/api/schema/export/?id='$SCHEMAID \
+    -H 'Authorization: Bearer '$TOKEN \
+    -O --output-dir /path/to/folder
+```
+
+## Export Tests
+
+```bash
+TESTID='123'
+curl 'http://localhost:8080/api/test/export/?id=$TESTID' \
+    -s -X POST -H 'content-type: application/json' \
+    -H 'Authorization: Bearer '$TOKEN \
+    -O --output-dir /path/to/folder
+```
diff --git a/docs/site/content/en/openapi/openapi.yaml b/docs/site/content/en/openapi/openapi.yaml
index 7cff19652..271e29932 100644
--- a/docs/site/content/en/openapi/openapi.yaml
+++ b/docs/site/content/en/openapi/openapi.yaml
@@ -1355,16 +1355,18 @@ paths:
     post:
       tags:
       - Schema
-      description: Import an previously exported Schema
+      description: Import an previously exported Schema either as a new Schema or
+        to update an existing Schema
       operationId: importSchema
       requestBody:
         content:
           application/json:
             schema:
-              type: string
+              $ref: '#/components/schemas/SchemaExport'
+        required: true
       responses:
-        "201":
-          description: Created
+        "204":
+          description: Import a new Schema or update an existing Schema
   /api/schema/{id}:
     get:
       tags:
@@ -1449,11 +1451,11 @@ paths:
         example: 101
       responses:
         "200":
-          description: A JSON representation of the Schema object
+          description: A JSON representation of the SchemaExport object
           content:
             application/json:
               schema:
-                type: string
+                $ref: '#/components/schemas/SchemaExport'
   /api/schema/{id}/resetToken:
     post:
       tags:
@@ -1780,16 +1782,18 @@ paths:
     post:
       tags:
       - Test
-      description: Import a previously exported Test
+      description: Import a previously exported Test either as a new Test or to update
+        an existing Test
       operationId: importTest
       requestBody:
         content:
           application/json:
             schema:
-              type: string
+              $ref: '#/components/schemas/TestExport'
+        required: true
       responses:
         "204":
-          description: Import a new test
+          description: Import a new Test or update an existing Test
   /api/test/summary:
     get:
       tags:
@@ -1898,11 +1902,11 @@ paths:
           type: integer
       responses:
         "200":
-          description: A Test defintion formatted as json
+          description: A Test definition formatted as json
           content:
             application/json:
               schema:
-                type: string
+                $ref: '#/components/schemas/TestExport'
   /api/test/{id}/fingerprint:
     get:
       tags:
@@ -2174,6 +2178,41 @@ components:
       - PROTECTED
       - PRIVATE
       type: string
+    Action:
+      required:
+      - id
+      - event
+      - type
+      - config
+      - testId
+      - active
+      - runAlways
+      type: object
+      properties:
+        id:
+          format: int32
+          type: integer
+        event:
+          type: string
+          nullable: false
+        type:
+          type: string
+          nullable: false
+        config:
+          type: array
+          nullable: false
+        testId:
+          format: int32
+          type: integer
+          nullable: false
+        active:
+          type: boolean
+          nullable: false
+        runAlways:
+          type: boolean
+          nullable: false
+        secrets:
+          type: array
     ActionLog:
       description: Action Log
       required:
@@ -2199,6 +2238,21 @@ components:
       - SAME
       - WORSE
       type: string
+    ChangeDetection:
+      required:
+      - id
+      - model
+      - config
+      type: object
+      properties:
+        id:
+          format: int32
+          type: integer
+        model:
+          type: string
+        config:
+          type: array
+          nullable: false
     ComparisonResult:
       description: Result of performing a Comparison
       type: object
@@ -2551,6 +2605,8 @@ components:
       - POSTGRES
       - ELASTICSEARCH
       type: string
+      example: ELASTICSEARCH
+      nullable: false
     ElasticsearchDatastoreConfig:
       description: Type of backend datastore
       required:
@@ -2981,6 +3037,34 @@ components:
             \ array or JSON object"
           type: string
           example: "1724"
+    MissingDataRule:
+      required:
+      - id
+      - maxStaleness
+      - testId
+      type: object
+      properties:
+        id:
+          format: int32
+          type: integer
+        name:
+          type: string
+        labels:
+          type: array
+          items:
+            type: string
+        condition:
+          type: string
+        maxStaleness:
+          format: int64
+          type: integer
+          nullable: false
+        lastNotification:
+          format: date-time
+          type: string
+        testId:
+          format: int32
+          type: integer
     PersistentLog:
       description: Persistent Log
       required:
@@ -3487,6 +3571,23 @@ components:
           type: string
           example: uri:my-schmea:0.1
           nullable: false
+    SchemaExport:
+      description: Represents a Schema with all associated data used for export/import
+        operations.
+      type: object
+      allOf:
+      - $ref: '#/components/schemas/Schema'
+      properties:
+        labels:
+          description: Array of Labels associated with schema
+          type: array
+          items:
+            $ref: '#/components/schemas/Label'
+        transformers:
+          description: Array of Transformers associated with schema
+          type: array
+          items:
+            $ref: '#/components/schemas/Transformer'
     SchemaQueryResult:
       required:
       - schemas
@@ -3964,6 +4065,41 @@ components:
           type: boolean
           example: true
           nullable: false
+    TestExport:
+      description: Represents a Test with all associated data used for export/import
+        operations.
+      type: object
+      allOf:
+      - $ref: '#/components/schemas/Test'
+      properties:
+        variables:
+          description: Array of Variables associated with test
+          type: array
+          items:
+            $ref: '#/components/schemas/Variable'
+        missingDataRules:
+          description: Array of MissingDataRules associated with test
+          type: array
+          items:
+            $ref: '#/components/schemas/MissingDataRule'
+        experiments:
+          description: Array of ExperimentProfiles associated with test
+          type: array
+          items:
+            $ref: '#/components/schemas/ExperimentProfile'
+        actions:
+          description: Array of Actions associated with test
+          type: array
+          items:
+            $ref: '#/components/schemas/Action'
+        subscriptions:
+          allOf:
+          - $ref: '#/components/schemas/Watch'
+          - description: Watcher object associated with test
+        datastore:
+          allOf:
+          - $ref: '#/components/schemas/Datastore'
+          - description: Datastore associated with test
     TestListing:
       type: object
       properties:
@@ -4207,6 +4343,43 @@ components:
           allOf:
           - $ref: '#/components/schemas/ErrorDetails'
           - description: Validation Error Details
+    Variable:
+      required:
+      - id
+      - testId
+      - name
+      - order
+      - labels
+      - changeDetection
+      type: object
+      properties:
+        id:
+          format: int32
+          type: integer
+        testId:
+          format: int32
+          type: integer
+          nullable: false
+        name:
+          type: string
+          nullable: false
+        group:
+          type: string
+        order:
+          format: int32
+          type: integer
+          nullable: false
+        labels:
+          type: array
+          items:
+            type: string
+          nullable: false
+        calculation:
+          type: string
+        changeDetection:
+          type: array
+          items:
+            $ref: '#/components/schemas/ChangeDetection'
     VersionInfo:
       required:
       - version
@@ -4223,3 +4396,32 @@ components:
           description: Timestamp of server startup
           type: integer
           example: 2023-10-18 18:00:57
+    Watch:
+      required:
+      - users
+      - optout
+      - teams
+      - testId
+      type: object
+      properties:
+        id:
+          format: int32
+          type: integer
+        users:
+          type: array
+          items:
+            type: string
+          nullable: false
+        optout:
+          type: array
+          items:
+            type: string
+          nullable: false
+        teams:
+          type: array
+          items:
+            type: string
+          nullable: false
+        testId:
+          format: int32
+          type: integer
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/ChangeDetection.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/ChangeDetection.java
index 6daa212b7..6f42e2402 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/ChangeDetection.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/ChangeDetection.java
@@ -3,7 +3,6 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.JsonNode;
 import jakarta.validation.constraints.NotNull;
-import org.eclipse.microprofile.openapi.annotations.media.Schema;
 
 public class ChangeDetection {
     @JsonProperty( required = true )
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/Variable.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/Variable.java
index a2ee91934..732a8b0d5 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/Variable.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/alerting/Variable.java
@@ -2,10 +2,10 @@
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.databind.JsonNode;
 import jakarta.validation.constraints.NotNull;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 
+import java.util.List;
 import java.util.Set;
 
 public class Variable {
@@ -23,19 +23,16 @@ public class Variable {
     public int order;
     @NotNull
     @JsonProperty(required = true)
-    public JsonNode labels;
+    public List<String> labels;
     @JsonInclude(JsonInclude.Include.NON_NULL)
     public String calculation;
-    @Schema(
-        required = true,
-        implementation = ChangeDetection[].class
-    )
+    @Schema(required = true, implementation = ChangeDetection[].class)
     public Set<ChangeDetection> changeDetection;
 
     public Variable() {
     }
 
-    public Variable(Integer id, int testId, String name, String group, int order, JsonNode labels, String calculation,
+    public Variable(Integer id, int testId, String name, String group, int order, List<String> labels, String calculation,
                     Set<ChangeDetection> changeDetection) {
         this.id = id;
         this.testId = testId;
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/ExperimentProfile.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/ExperimentProfile.java
index 52ec52bc1..4e217bbb2 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/ExperimentProfile.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/ExperimentProfile.java
@@ -1,6 +1,8 @@
 package io.hyperfoil.tools.horreum.api.data;
 
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
 import com.fasterxml.jackson.databind.JsonNode;
 import jakarta.validation.constraints.NotNull;
 import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
@@ -8,6 +10,7 @@
 
 import java.util.Collection;
 
+@JsonIdentityInfo( property = "id", generator = ObjectIdGenerators.PropertyGenerator.class)
 @Schema(description = "An Experiment Profile defines the labels and filters for the dataset and baseline")
 public class ExperimentProfile {
     @JsonProperty(required = true )
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Label.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Label.java
index 32f940890..15263006b 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Label.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Label.java
@@ -44,6 +44,11 @@ public class Label extends ProtectedType {
     public Label() {
     }
 
+    public Label(String name, int schemaId) {
+        this.name = name;
+        this.schemaId = schemaId;
+    }
+
     public static class Value implements Serializable {
         public int datasetId;
         public int labelId;
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Schema.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Schema.java
index 2c0915274..d8d333187 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Schema.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Schema.java
@@ -46,6 +46,17 @@ public Schema() {
         access = Access.PUBLIC;
     }
 
+    public Schema(Schema s) {
+        this.id = s.id;
+        this.uri = s.uri;
+        this.name = s.name;
+        this.description = s.description;
+        this.schema = s.schema;
+        this.token = s.token;
+        this.access = s.access;
+        this.owner = s.owner;
+    }
+
     public static class ValidationEvent {
         public int id;
         public Collection<ValidationError> errors;
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/SchemaExport.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/SchemaExport.java
new file mode 100644
index 000000000..80707f3e8
--- /dev/null
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/SchemaExport.java
@@ -0,0 +1,23 @@
+package io.hyperfoil.tools.horreum.api.data;
+
+import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
+
+import java.util.List;
+
+@org.eclipse.microprofile.openapi.annotations.media.Schema(type = SchemaType.OBJECT, allOf = Schema.class,
+        description = "Represents a Schema with all associated data used for export/import operations.")
+public class SchemaExport extends Schema {
+
+    @org.eclipse.microprofile.openapi.annotations.media.Schema(description = "Array of Labels associated with schema")
+    public List<Label> labels;
+    @org.eclipse.microprofile.openapi.annotations.media.Schema(description = "Array of Transformers associated with schema")
+    public List<Transformer> transformers;
+
+    public SchemaExport() {
+    }
+
+    public SchemaExport(Schema s) {
+        super(s);
+    }
+
+}
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Test.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Test.java
index 0a7a81e79..0048fc271 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Test.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/Test.java
@@ -1,6 +1,8 @@
 package io.hyperfoil.tools.horreum.api.data;
 
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
 import com.fasterxml.jackson.databind.JsonNode;
 import jakarta.validation.constraints.NotNull;
 import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
@@ -63,6 +65,23 @@ public Test() {
         this.access = Access.PUBLIC;
     }
 
+    public Test(Test t) {
+        id = t.id;
+        name = t.name;
+        folder = t.folder;
+        description = t.description;
+        tokens = t.tokens;
+        timelineLabels = t.timelineLabels;
+        timelineFunction = t.timelineFunction;
+        fingerprintLabels = t.fingerprintLabels;
+        fingerprintFilter = t.fingerprintFilter;
+        compareUrl = t.compareUrl;
+        transformers = t.transformers;
+        notificationsEnabled = t.notificationsEnabled;
+        access = t.access;
+        owner = t.owner;
+    }
+
     @Override
     public String toString() {
         return "Test{" +
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/TestExport.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/TestExport.java
new file mode 100644
index 000000000..7a6f0b228
--- /dev/null
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/TestExport.java
@@ -0,0 +1,78 @@
+package io.hyperfoil.tools.horreum.api.data;
+
+import io.hyperfoil.tools.horreum.api.alerting.MissingDataRule;
+import io.hyperfoil.tools.horreum.api.alerting.Variable;
+import io.hyperfoil.tools.horreum.api.alerting.Watch;
+import io.hyperfoil.tools.horreum.api.data.datastore.Datastore;
+import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+import java.util.List;
+
+@Schema(type = SchemaType.OBJECT, allOf = Test.class,
+    description = "Represents a Test with all associated data used for export/import operations.")
+public class TestExport extends Test {
+
+    @Schema(description = "Array of Variables associated with test")
+    public List<Variable> variables;
+    @Schema(description = "Array of MissingDataRules associated with test")
+    public List<MissingDataRule> missingDataRules;
+    @Schema(description = "Array of ExperimentProfiles associated with test")
+    public List<ExperimentProfile> experiments;
+    @Schema(description = "Array of Actions associated with test")
+    public List<Action> actions;
+    @Schema(description = "Watcher object associated with test")
+    public Watch subscriptions;
+
+    @Schema(description = "Datastore associated with test")
+    public Datastore datastore;
+
+    public TestExport() {
+        super();
+    }
+    public TestExport(Test t) {
+        super(t);
+    }
+
+    //need to propagate the changes to newTest into the existing properties
+    public void update(Test newTest) {
+        id = newTest.id;
+    }
+
+    public void updateRefs() {
+        //need to make sure the correct variables are used by experiments
+        if(variables != null && !variables.isEmpty())
+            variables.forEach(variable -> variable.testId = id);
+
+        if(experiments != null && !experiments.isEmpty()) {
+            for(ExperimentProfile experiment : experiments) {
+                experiment.testId = id;
+            }
+        }
+        if(actions != null && !actions.isEmpty()) {
+            for(Action action : actions) {
+                action.testId = id;
+            }
+        }
+        if(subscriptions != null) {
+            subscriptions.testId = id;
+        }
+        if(missingDataRules != null && !missingDataRules.isEmpty()) {
+            for(MissingDataRule rule : missingDataRules) {
+                rule.testId = id;
+            }
+        }
+    }
+    public void updateExperimentsVariableId(int oldVarId, int newVarId) {
+        if(experiments != null && !experiments.isEmpty()) {
+            for(ExperimentProfile experiment : experiments) {
+                if(experiment.comparisons != null && !experiment.comparisons.isEmpty()) {
+                    experiment.comparisons.forEach(c -> {
+                        if(c.variableId == oldVarId)
+                            c.variableId = newVarId;
+                    });
+                }
+            }
+        }
+    }
+}
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/datastore/Datastore.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/datastore/Datastore.java
index a8252f5a3..ae646a634 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/datastore/Datastore.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/data/datastore/Datastore.java
@@ -41,5 +41,10 @@ public class Datastore extends ProtectedType {
     @Schema( type = SchemaType.STRING, implementation = DatastoreType.class, example = "ELASTICSEARCH")
     public DatastoreType type;
 
-
+    public void pruneSecrets() {
+        if (config != null) {
+            config.remove("apiKey");
+            config.remove("password");
+        }
+    }
 }
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/SchemaService.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/SchemaService.java
index 17538d866..b57553ea6 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/SchemaService.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/SchemaService.java
@@ -1,9 +1,11 @@
 package io.hyperfoil.tools.horreum.api.services;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.hyperfoil.tools.horreum.api.SortDirection;
 import io.hyperfoil.tools.horreum.api.data.Label;
 import io.hyperfoil.tools.horreum.api.data.Schema;
+import io.hyperfoil.tools.horreum.api.data.SchemaExport;
 import io.hyperfoil.tools.horreum.api.data.Transformer;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -239,19 +241,19 @@ int addOrUpdateTransformer(@PathParam("schemaId") int schemaId,
    @Parameters(value = {
            @Parameter(name = "id", description = "Schema ID", example = "101"),
    })
-   @APIResponseSchema(value = String.class,
-           responseDescription = "A JSON representation of the Schema object",
+   @APIResponseSchema(value = SchemaExport.class,
+           responseDescription = "A JSON representation of the SchemaExport object",
            responseCode = "200")
-   String exportSchema(@PathParam("id") int id);
+   SchemaExport exportSchema(@PathParam("id") int id);
 
    @POST
    @Path("import")
    @Consumes(MediaType.APPLICATION_JSON)
-   @RequestBody(content = @Content( mediaType = MediaType.APPLICATION_JSON,
-           schema = @org.eclipse.microprofile.openapi.annotations.media.Schema(
-                   type = SchemaType.STRING, implementation = String.class)) )
-   @Operation(description="Import an previously exported Schema")
-   void importSchema(String config);
+   @APIResponse(responseCode = "204", description = "Import a new Schema or update an existing Schema")
+   @RequestBody(required = true, content = @Content( mediaType = MediaType.APPLICATION_JSON,
+           schema = @org.eclipse.microprofile.openapi.annotations.media.Schema( implementation = SchemaExport.class)) )
+   @Operation(description="Import an previously exported Schema either as a new Schema or to update an existing Schema")
+   void importSchema(ObjectNode config);
 
    class SchemaQueryResult {
       @NotNull
diff --git a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/TestService.java b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/TestService.java
index 26f1bad38..1304f7075 100644
--- a/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/TestService.java
+++ b/horreum-api/src/main/java/io/hyperfoil/tools/horreum/api/services/TestService.java
@@ -1,8 +1,10 @@
 package io.hyperfoil.tools.horreum.api.services;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.hyperfoil.tools.horreum.api.SortDirection;
 import io.hyperfoil.tools.horreum.api.data.Access;
+import io.hyperfoil.tools.horreum.api.data.TestExport;
 import io.hyperfoil.tools.horreum.api.data.Fingerprints;
 import io.hyperfoil.tools.horreum.api.data.ExportedLabelValues;
 import io.hyperfoil.tools.horreum.api.data.ProtectedType;
@@ -228,18 +230,20 @@ List<ExportedLabelValues> listLabelValues(@PathParam("id") int testId,
 
    @GET
    @Path("{id}/export")
-   @APIResponseSchema(value = String.class,
-           responseDescription = "A Test defintion formatted as json",
+   @Produces(MediaType.APPLICATION_JSON)
+   @APIResponseSchema(value = TestExport.class,
+           responseDescription = "A Test definition formatted as json",
            responseCode = "200")
-   String export(@PathParam("id") int testId);
+   TestExport export(@PathParam("id") int testId);
 
    @POST
    @Path("import")
-   @APIResponse(responseCode = "204", description = "Import a new test")
-   @RequestBody(content = @Content( mediaType = MediaType.APPLICATION_JSON,
-           schema = @Schema( type = SchemaType.STRING, implementation = String.class)) )
-   @Operation(description="Import a previously exported Test")
-   void importTest( String testConfig);
+   @Consumes(MediaType.APPLICATION_JSON)
+   @APIResponse(responseCode = "204", description = "Import a new Test or update an existing Test")
+   @RequestBody(required = true, content = @Content( mediaType = MediaType.APPLICATION_JSON,
+           schema = @Schema(implementation = TestExport.class)) )
+   @Operation(description="Import a previously exported Test either as a new Test or to update an existing Test")
+   void importTest(ObjectNode test);
 
    class TestListing {
       @Schema(description = "Array of Test Summaries")
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/entity/ExperimentProfileDAO.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/entity/ExperimentProfileDAO.java
index cc8727958..ad7b094bc 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/entity/ExperimentProfileDAO.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/entity/ExperimentProfileDAO.java
@@ -1,6 +1,7 @@
 package io.hyperfoil.tools.horreum.entity;
 
 import java.util.Collection;
+import java.util.List;
 
 import io.hyperfoil.tools.horreum.hibernate.JsonBinaryType;
 import jakarta.persistence.CollectionTable;
@@ -67,7 +68,7 @@ public class ExperimentProfileDAO extends PanacheEntityBase {
    @ElementCollection(fetch = FetchType.EAGER)
    @CollectionTable(name="experiment_comparisons", joinColumns=@JoinColumn(name="profile_id"))
    @OrderBy("variable_id, model")
-   public Collection<ExperimentComparisonDAO> comparisons;
+   public List<ExperimentComparisonDAO> comparisons;
 
    /* These labels are not used in Horreum but are added to the result event */
    @Column(name = "extra_labels", columnDefinition = "jsonb")
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/ExperimentProfileMapper.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/ExperimentProfileMapper.java
index 0a1960fdc..8cd3b1685 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/ExperimentProfileMapper.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/ExperimentProfileMapper.java
@@ -27,8 +27,10 @@ public static ExperimentProfile from(ExperimentProfileDAO ep) {
 
     public static ExperimentComparison fromExperimentComparison(ExperimentComparisonDAO ec) {
         ExperimentComparison dto = new ExperimentComparison();
-        dto.variableId = ec.getVariableId();
-        dto.variableName = ec.variable.name;
+        if(ec.variable != null) {
+            dto.variableId = ec.variable.id;
+            dto.variableName = ec.variable.name;
+        }
         dto.config = ec.config;
         dto.model = ec.model;
 
@@ -56,7 +58,6 @@ public static ExperimentComparisonDAO toExperimentComparison(ExperimentCompariso
         ec.model = dto.model;
         if(dto.variableId != null && dto.variableId > 0)
             ec.setVariableId(dto.variableId);
-
         return ec;
     }
 }
\ No newline at end of file
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/LabelMapper.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/LabelMapper.java
index 98e1e0382..194e27013 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/LabelMapper.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/LabelMapper.java
@@ -9,6 +9,8 @@
 
 public class LabelMapper {
     public static Label from(LabelDAO l) {
+        if(l == null)
+            return  null;
         Label dto = new Label();
         dto.id = l.id;
         dto.name = l.name;
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/VariableMapper.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/VariableMapper.java
index 7cddafbb6..ac9c172a7 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/VariableMapper.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/mapper/VariableMapper.java
@@ -1,17 +1,36 @@
 package io.hyperfoil.tools.horreum.mapper;
 
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 import io.hyperfoil.tools.horreum.entity.alerting.VariableDAO;
 import io.hyperfoil.tools.horreum.api.alerting.Variable;
+import io.hyperfoil.tools.horreum.entity.data.LabelDAO;
 
+import java.util.ArrayList;
 import java.util.stream.Collectors;
 
 public class VariableMapper {
 
-    public static Variable from(VariableDAO variable) {
-        return new Variable(variable.id, variable.testId, variable.name, variable.group,
-                variable.order, variable.labels, variable.calculation,
-                variable.changeDetection.stream().map(ChangeDetectionMapper::from).collect(Collectors.toSet())
-        );
+    public static Variable from(VariableDAO dao) {
+        Variable v = new Variable();
+        v.id = dao.id;
+        v.testId = dao.testId;
+        v.name = dao.name;
+        v.group = dao.group;
+        v.order = dao.order;
+        v.calculation = dao.calculation;
+        v.changeDetection =
+        dao.changeDetection.stream().map(ChangeDetectionMapper::from).collect(Collectors.toSet());
+        //label
+        if(dao.labels.isArray()) {
+            v.labels = new ArrayList<>();
+            dao.labels.spliterator().forEachRemaining(n -> {
+                LabelDAO l = LabelDAO.find("name", n.asText()).firstResult();
+                if(l != null)
+                    v.labels.add( LabelMapper.from(l).name);
+            });
+        }
+        return v;
     }
 
     public static VariableDAO to(Variable dto) {
@@ -21,7 +40,12 @@ public static VariableDAO to(Variable dto) {
         v.name = dto.name;
         v.group = dto.group;
         v.order = dto.order;
-        v.labels = dto.labels;
+        if(dto.labels != null && !dto.labels.isEmpty()) {
+            ArrayNode n = JsonNodeFactory.instance.arrayNode();
+            for (String l : dto.labels)
+                n.add(l);
+            v.labels = n;
+        }
         v.calculation = dto.calculation;
         if(dto.changeDetection != null)
             v.changeDetection = dto.changeDetection.stream().map(ChangeDetectionMapper::to).collect(Collectors.toSet());
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ActionServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ActionServiceImpl.java
index 090a515ee..4ea3091db 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ActionServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ActionServiceImpl.java
@@ -2,6 +2,7 @@
 
 import io.hyperfoil.tools.horreum.api.data.Action;
 import io.hyperfoil.tools.horreum.api.data.AllowedSite;
+import io.hyperfoil.tools.horreum.api.data.TestExport;
 import io.hyperfoil.tools.horreum.api.data.Run;
 import io.hyperfoil.tools.horreum.api.data.Test;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
@@ -37,6 +38,7 @@
 import jakarta.transaction.Transactional;
 
 import java.security.GeneralSecurityException;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
@@ -44,7 +46,6 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
@@ -307,57 +308,25 @@ public void onNewExperimentResult(ExperimentService.ExperimentResult result) {
       executeActions(MessageBusChannels.EXPERIMENT_RESULT_NEW, result.profile.testId, result, result.notify);
    }
 
-   JsonNode exportTest(int testId) {
-      ArrayNode actions = JsonNodeFactory.instance.arrayNode();
-      for (ActionDAO action : ActionDAO.<ActionDAO>list("testId", testId)) {
-         ObjectNode node = Util.OBJECT_MAPPER.valueToTree(ActionMapper.from(action));
-         if (!action.secrets.isEmpty()) {
-            try {
-               node.put("secrets", encryptionManager.encrypt(action.secrets.toString()));
-            } catch (GeneralSecurityException e) {
-               throw ServiceException.serverError("Cannot encrypt secrets for action " + action.id);
-            }
-         }
-         actions.add(node);
+   void exportTest(TestExport test) {
+      List<Action> actions = new ArrayList<>();
+      for (ActionDAO action : ActionDAO.<ActionDAO>list("testId", test.id)) {
+         Action a = ActionMapper.from(action);
+         action.secrets = JsonNodeFactory.instance.objectNode();
+         actions.add(a);
       }
-      return actions;
+      test.actions = actions;
    }
 
-   void importTest(int testId, JsonNode actions, boolean forceUseTestId) {
-      if (actions.isMissingNode() || actions.isNull()) {
-         log.debugf("Import test %d: no actions");
-      } else if (actions.isArray()) {
-         log.debugf("Importing %d actions for test %d", actions.size(), testId);
-         for (JsonNode node : actions) {
-            if (!node.isObject()) {
-               throw ServiceException.badRequest("Test actions must be an array of objects");
-            }
-            String secretsEncrypted = ((ObjectNode) node).remove("secrets").textValue();
-            try {
-               ActionDAO action = ActionMapper.to(Util.OBJECT_MAPPER.treeToValue(node, Action.class));
-               if(forceUseTestId)
-                  action.testId = testId;
-               else {
-                  if (action.testId == null) {
-                     action.testId = testId;
-                  } else if (action.testId != testId) {
-                     throw ServiceException.badRequest("Action id '" + node.path("id") + "' belongs to a different test: " + action.testId);
-                  }
-               }
-               if (secretsEncrypted != null) {
-                  action.secrets = Util.OBJECT_MAPPER.readTree(encryptionManager.decrypt(secretsEncrypted));
-               } else {
-                  action.secrets = JsonNodeFactory.instance.objectNode();
-               }
-               em.merge(action);
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize action id '" + node.path("id").asText() + "': " + e.getMessage());
-            } catch (GeneralSecurityException e) {
-               throw ServiceException.badRequest("Cannot decrypt secrets for action id '" + node.path("id").asText() + "': " + e.getMessage());
-            }
+   void importTest(TestExport test) {
+      for (Action a : test.actions) {
+         ActionDAO action = ActionMapper.to(a);
+         if(ActionDAO.findById(action.id) == null) {
+            action.id = null;
+            action.persist();
          }
-      } else {
-         throw ServiceException.badRequest("Actions are invalid: " + actions.getNodeType());
+         else
+            em.merge(action);
       }
    }
 }
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/AlertingServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/AlertingServiceImpl.java
index 3ea030f0e..bd6172545 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/AlertingServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/AlertingServiceImpl.java
@@ -22,10 +22,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
-import io.hyperfoil.tools.horreum.api.data.Dataset;
-import io.hyperfoil.tools.horreum.api.data.Run;
+import io.hyperfoil.tools.horreum.api.data.*;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
 import io.hyperfoil.tools.horreum.hibernate.IntArrayType;
 import io.hyperfoil.tools.horreum.hibernate.JsonBinaryType;
@@ -43,7 +41,6 @@
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Response;
 
-import io.hyperfoil.tools.horreum.api.data.ConditionConfig;
 import io.hyperfoil.tools.horreum.api.alerting.*;
 import io.hyperfoil.tools.horreum.api.changes.Dashboard;
 import io.hyperfoil.tools.horreum.api.changes.Target;
@@ -66,7 +63,6 @@
 import org.hibernate.type.StandardBasicTypes;
 import org.jboss.logging.Logger;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
@@ -186,8 +182,8 @@ DISTINCT ON(variable_id) variable_id AS variable,
    private static final Instant VERY_DISTANT_FUTURE = Instant.parse("2666-06-06T06:06:06.00Z");
 
    private static final Map<String, ChangeDetectionModel> MODELS = Map.of(
-         RelativeDifferenceChangeDetectionModel.NAME, new RelativeDifferenceChangeDetectionModel(),
-         FixedThresholdModel.NAME, new FixedThresholdModel());
+           RelativeDifferenceChangeDetectionModel.NAME, new RelativeDifferenceChangeDetectionModel(),
+           FixedThresholdModel.NAME, new FixedThresholdModel());
 
    @Inject
    TestServiceImpl testService;
@@ -246,7 +242,7 @@ public void onLabelsUpdated(Dataset.LabelsUpdatedEvent event) {
          // Retry `horreum.alerting.updateLabel.retries` times before logging a warning
          retryCounterSet.putIfAbsent(event.datasetId, new AtomicInteger(0));
          int retryCounter = retryCounterSet.get(event.datasetId).getAndIncrement();
-         if ( retryCounter < labelCalcRetries ) {
+         if (retryCounter < labelCalcRetries) {
             log.infof("Retrying labels update for dataset %d, attempt %d/%d", event.datasetId, retryCounter, this.labelCalcRetries);
             vertx.setTimer(1000, timerId -> messageBus.executeForTest(event.datasetId, () -> Util.withTx(tm, () -> {
                        onLabelsUpdated(event);
@@ -266,7 +262,7 @@ public void onLabelsUpdated(Dataset.LabelsUpdatedEvent event) {
       } else {
          try {
             sendNotifications = (Boolean) em.createNativeQuery("SELECT notificationsenabled FROM test WHERE id = ?")
-                  .setParameter(1, dataset.testid).getSingleResult();
+                    .setParameter(1, dataset.testid).getSingleResult();
          } catch (NoResultException e) {
             sendNotifications = true;
          }
@@ -307,7 +303,7 @@ private void createMissingDataRuleResult(DatasetDAO dataset, int ruleId) {
    }
 
    private void recalculateDatapointsForDataset(DatasetDAO dataset, boolean notify, boolean debug, Recalculation recalculation) {
-      log.debugf("Analyzing dataset %d (%d/%d)", (long)dataset.id, (long)dataset.run.id, dataset.ordinal);
+      log.debugf("Analyzing dataset %d (%d/%d)", (long) dataset.id, (long) dataset.run.id, dataset.ordinal);
       TestDAO test = TestDAO.findById(dataset.testid);
       if (test == null) {
          log.errorf("Cannot load test ID %d", dataset.testid);
@@ -339,72 +335,47 @@ private boolean testFingerprint(DatasetDAO dataset, String filter) {
          fingerprint = JsonNodeFactory.instance.nullNode();
       }
       boolean testResult = Util.evaluateTest(filter, fingerprint,
-            value -> {
-               logCalculationMessage(dataset, PersistentLogDAO.ERROR, "Evaluation of fingerprint failed: '%s' is not a boolean", value);
-               return false;
-            },
-            (code, e) -> logCalculationMessage(dataset, PersistentLogDAO.ERROR, "Evaluation of fingerprint filter failed: '%s' Code:<pre>%s</pre>", e.getMessage(), code),
-            output -> logCalculationMessage(dataset, PersistentLogDAO.DEBUG, "Output while evaluating fingerprint filter: <pre>%s</pre>", output));
+              value -> {
+                 logCalculationMessage(dataset, PersistentLogDAO.ERROR, "Evaluation of fingerprint failed: '%s' is not a boolean", value);
+                 return false;
+              },
+              (code, e) -> logCalculationMessage(dataset, PersistentLogDAO.ERROR, "Evaluation of fingerprint filter failed: '%s' Code:<pre>%s</pre>", e.getMessage(), code),
+              output -> logCalculationMessage(dataset, PersistentLogDAO.DEBUG, "Output while evaluating fingerprint filter: <pre>%s</pre>", output));
       if (!testResult) {
          logCalculationMessage(dataset, PersistentLogDAO.DEBUG, "Fingerprint %s was filtered out.", fingerprint);
       }
       return testResult;
    }
 
-   JsonNode exportTest(int testId) {
-      ObjectNode config = JsonNodeFactory.instance.objectNode();
-      List<VariableDAO> variables = VariableDAO.list("testId", testId);
-      config.set("variables", Util.OBJECT_MAPPER.valueToTree(variables.stream().map(VariableMapper::from).collect(Collectors.toList())));
-      List<MissingDataRuleDAO> rules = MissingDataRuleDAO.list("test.id", testId);
-      config.set("missingDataRules", Util.OBJECT_MAPPER.valueToTree(rules.stream().map(MissingDataRuleMapper::from).collect(Collectors.toList())));
-      return config;
+   void exportTest(TestExport test) {
+      test.variables = VariableDAO.<VariableDAO>list("testId", test.id).stream().map(VariableMapper::from).collect(Collectors.toList());
+      test.missingDataRules = MissingDataRuleDAO.<MissingDataRuleDAO>list("test.id", test.id).stream().map(MissingDataRuleMapper::from).collect(Collectors.toList());
    }
 
-   void importTest(int testId, JsonNode config, boolean forceUseTestId) {
-      JsonNode variablesNode = config.path("variables");
-      if (variablesNode.isMissingNode() || variablesNode.isNull()) {
-         log.debugf("Importing test %d: no change detection variables", testId);
-      } else if (variablesNode.isArray()) {
-         log.debugf("Importing %d change detection variables for test %d", variablesNode.size(), testId);
-         for (var node : variablesNode) {
-            try {
-               VariableDAO variable = VariableMapper.to(Util.OBJECT_MAPPER.treeToValue(node, Variable.class));
-               variable.testId = testId;
-               variable.ensureLinked();
-               if(forceUseTestId) {
-                 variable.flushIds();
-                 variable.persist();
-               }
-               else
-                  em.merge(variable);
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize change detection variable with id '" + node.path("id").asText() + "': " + e.getMessage());
+   void importVariables(TestExport test) {
+      for (var v : test.variables) {
+            VariableDAO variable = VariableMapper.to(v);
+            variable.ensureLinked();
+            if(VariableDAO.findById(variable.id) == null) {
+               int prevId = variable.id;
+               variable.flushIds();
+               variable.persist();
+               test.updateExperimentsVariableId(prevId, variable.id);
             }
-         }
-      } else {
-         throw ServiceException.badRequest("Change detection variables are invalid: " + variablesNode.getNodeType());
+            else
+               em.merge(variable);
       }
-      JsonNode rulesNode = config.path("missingDataRules");
-      if (rulesNode.isMissingNode() || rulesNode.isNull()) {
-         log.debugf("Importing test %d: no missing data rules", testId);
-      } else if (rulesNode.isArray()) {
-         log.debugf("Importing %d missing data rules for test %d", rulesNode.size(), testId);
-         for (var node : rulesNode) {
-            try {
-               if(forceUseTestId) {
-                  MissingDataRule dto = Util.OBJECT_MAPPER.treeToValue(node, MissingDataRule.class);
-                  dto.testId = testId;
-                  dto.id = null;
-                  em.persist(MissingDataRuleMapper.to(dto));
-               }
-               else
-                  em.merge(MissingDataRuleMapper.to(Util.OBJECT_MAPPER.treeToValue(node, MissingDataRule.class)));
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize missing data rule with id '" + node.path("id").asText() + "': " + e.getMessage());
-            }
+   }
+
+   void importMissingDataRules(TestExport test) {
+      for (var rule : test.missingDataRules) {
+         if(MissingDataRuleDAO.findById(rule.id) != null) {
+            em.merge(MissingDataRuleMapper.to(rule));
+         }
+         else {
+            rule.id = null;
+            em.persist(MissingDataRuleMapper.to(rule));
          }
-      } else {
-         throw ServiceException.badRequest("Missing data rules are invalid: " + rulesNode.getNodeType());
       }
    }
 
@@ -759,9 +730,6 @@ public void updateVariables(int testId, List<Variable> variablesDTO) {
       for (Variable v : variablesDTO) {
          if (v.name == null || v.name.isBlank()) {
             throw ServiceException.badRequest("Variable name is mandatory!");
-         } else if (v.labels == null || !v.labels.isArray() ||
-               StreamSupport.stream(v.labels.spliterator(), false).anyMatch(l -> !l.isTextual())) {
-            throw ServiceException.badRequest("Variable labels must be an array of label names");
          }
       }
       try {
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ExperimentServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ExperimentServiceImpl.java
index 7905d018f..ec1f1791e 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ExperimentServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ExperimentServiceImpl.java
@@ -11,6 +11,7 @@
 import java.util.stream.Collectors;
 
 import io.hyperfoil.tools.horreum.api.alerting.DataPoint;
+import io.hyperfoil.tools.horreum.api.data.TestExport;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
 import io.hyperfoil.tools.horreum.hibernate.JsonBinaryType;
 import jakarta.annotation.security.PermitAll;
@@ -21,12 +22,10 @@
 import jakarta.transaction.TransactionManager;
 import jakarta.transaction.Transactional;
 
-import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.hyperfoil.tools.horreum.api.data.Dataset;
 import io.hyperfoil.tools.horreum.api.data.ExperimentComparison;
 import io.hyperfoil.tools.horreum.api.data.ExperimentProfile;
 import io.hyperfoil.tools.horreum.entity.*;
-import io.hyperfoil.tools.horreum.entity.alerting.VariableDAO;
 import io.hyperfoil.tools.horreum.entity.data.*;
 import io.hyperfoil.tools.horreum.mapper.DatasetMapper;
 import io.hyperfoil.tools.horreum.mapper.DatasetLogMapper;
@@ -37,7 +36,6 @@
 import org.hibernate.type.StandardBasicTypes;
 import org.jboss.logging.Logger;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 
 import io.hyperfoil.tools.horreum.api.data.ConditionConfig;
@@ -307,47 +305,24 @@ JOIN label ON json_contains(ep.extra_labels, label.name)
       }
    }
 
-   JsonNode exportTest(int testId) {
-      List<ExperimentProfileDAO> experimentProfiles = ExperimentProfileDAO.list("test.id", testId);
-      return Util.OBJECT_MAPPER.valueToTree(experimentProfiles.stream().map(ExperimentProfileMapper::from).collect(Collectors.toList()));
+   void exportTest(TestExport test) {
+      test.experiments = ExperimentProfileDAO.<ExperimentProfileDAO>list("test.id", test.id)
+              .stream().map(ExperimentProfileMapper::from).collect(Collectors.toList());
    }
 
-   void importTest(int testId, JsonNode experiments, boolean forceUseTestId) {
-      if (experiments.isMissingNode() || experiments.isNull()) {
-         log.infof("Import test %d: no experiment profiles", testId);
-      } else if (experiments.isArray()) {
-         for (JsonNode node : experiments) {
-            ExperimentProfileDAO profile;
-            try {
-               if (node.has("comparisons") ){
-                  node.get("comparisons").forEach( (compNode) ->{
-                     VariableDAO variableDAO = VariableDAO.<VariableDAO>find("id = ?1 and testId = ?2", compNode.get("variableId").asText() , testId).firstResult();
-                     if ( variableDAO != null ) {
-                        Integer variableID = variableDAO.id;
-                        ((ObjectNode) compNode).put("variableId", variableID);
-                     } else {
-                        log.warnf("Could not import comparison for variable: %s", compNode.get("variableId").asText());
-                        ((ObjectNode) compNode).remove("variableId");
-                     }
-
-                  });
-
-               }
-
-               profile = ExperimentProfileMapper.to(Util.OBJECT_MAPPER.treeToValue(node, ExperimentProfile.class));
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize experiment profile id '" + node.path("id").asText() + "': " + e.getMessage());
-            }
-            if(forceUseTestId || profile.test == null) {
-               profile.test = em.getReference(TestDAO.class, testId);
-            }
-            else if (profile.test.id != testId) {
-               throw ServiceException.badRequest("Wrong test id in experiment profile id '" + node.path("id").asText() + "'");
-            }
+   void importTest(TestExport test) {
+      for (ExperimentProfile ep : test.experiments) {
+         ExperimentProfileDAO profile = ExperimentProfileMapper.to(ep);
+         if(ExperimentProfileDAO.findById(ep.id) != null) {
             em.merge(profile);
          }
-      } else {
-         throw ServiceException.badRequest("Experiment profiles are invalid: " + experiments.getNodeType());
+         else {
+            profile.id = null;
+            if(profile.test == null) {
+               profile.test = em.getReference(TestDAO.class, test.id);
+            }
+            profile.persist();
+         }
       }
    }
 }
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SchemaServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SchemaServiceImpl.java
index d8a3c0e24..0b0a26c6e 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SchemaServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SchemaServiceImpl.java
@@ -8,8 +8,10 @@
 import io.hyperfoil.tools.horreum.api.data.Extractor;
 import io.hyperfoil.tools.horreum.api.data.Label;
 import io.hyperfoil.tools.horreum.api.data.Schema;
+import io.hyperfoil.tools.horreum.api.data.SchemaExport;
 import io.hyperfoil.tools.horreum.api.data.Transformer;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
+import io.hyperfoil.tools.horreum.entity.alerting.VariableDAO;
 import io.hyperfoil.tools.horreum.entity.data.DatasetDAO;
 import io.hyperfoil.tools.horreum.entity.data.LabelDAO;
 import io.hyperfoil.tools.horreum.entity.data.RunDAO;
@@ -24,6 +26,7 @@
 import io.hyperfoil.tools.horreum.bus.MessageBus;
 import io.hyperfoil.tools.horreum.entity.ValidationErrorDAO;
 import io.hyperfoil.tools.horreum.mapper.ValidationErrorMapper;
+import io.hyperfoil.tools.horreum.mapper.VariableMapper;
 import io.hyperfoil.tools.horreum.server.WithRoles;
 import io.hyperfoil.tools.horreum.server.WithToken;
 import io.hypersistence.utils.hibernate.type.json.JsonBinaryType;
@@ -837,66 +840,49 @@ public List<TransformerInfo> allTransformers() {
    @WithRoles
    @Transactional
    @Override
-   public String exportSchema(int id) {
+   public SchemaExport exportSchema(int id) {
       SchemaDAO schema = SchemaDAO.findById(id);
       if (schema == null) {
          throw ServiceException.notFound("Schema not found");
       }
-      ObjectNode exported = Util.OBJECT_MAPPER.valueToTree(schema);
-      exported.set("labels", Util.OBJECT_MAPPER.valueToTree(LabelDAO.list("schema", schema)));
-      exported.set("transformers", Util.OBJECT_MAPPER.valueToTree(TransformerDAO.list("schema", schema)));
-      return exported.toString();
+      SchemaExport export = new SchemaExport(SchemaMapper.from(schema));
+
+      export.labels = LabelDAO.<LabelDAO>list("schema.id", schema.id).stream().map(LabelMapper::from).collect(Collectors.toList());
+      export.transformers = TransformerDAO.<TransformerDAO>list("schema.id", schema.id).stream().map(TransformerMapper::from).collect(Collectors.toList());
+
+      return export;
    }
 
    @RolesAllowed({Roles.TESTER, Roles.ADMIN})
    @WithRoles
    @Transactional
    @Override
-   public void importSchema(String importSchema) {
-      JsonNode config = null;
-      try {
-         config = Util.OBJECT_MAPPER.readValue(importSchema, JsonNode.class);
-      } catch (JsonProcessingException e) {
-         throw ServiceException.badRequest("Could not map Schema to JsonNode: "+e.getMessage());
-      }
-      if (!config.isObject()) {
-         throw ServiceException.badRequest("Bad format of schema; expecting an object");
-      }
-      // deep copy if we need to retry
-      ObjectNode cfg = config.deepCopy();
-      JsonNode labels = cfg.remove("labels");
-      JsonNode transformers = cfg.remove("transformers");
-      SchemaDAO schema;
-      try {
-         schema = SchemaMapper.to(Util.OBJECT_MAPPER.treeToValue(cfg, Schema.class));
-      } catch (JsonProcessingException e) {
-         throw ServiceException.badRequest("Cannot deserialize schema: " + e.getMessage());
-      }
+   public void importSchema(ObjectNode node) {
+      SchemaExport importSchema = Util.OBJECT_MAPPER.convertValue(node, SchemaExport.class);
       boolean newSchema = true;
-      if ( schema.id != null ) {
+      SchemaDAO schema = null;
+      if ( importSchema.id != null ) {
          //first check if this schema exists
-         SchemaDAO original = SchemaDAO.findById(schema.id);
-         if(original != null) {
-            em.merge(schema);
+         schema = SchemaDAO.findById(importSchema.id);
+         if(schema != null) {
+            em.merge(SchemaMapper.to(importSchema));
             newSchema = false;
          }
          else {
-            verifyNewSchema(SchemaMapper.from(schema));
+            verifyNewSchema(importSchema);
+            schema = SchemaMapper.to(importSchema);
             schema.id = null;
             schema.persist();
          }
       }
       else {
-         verifyNewSchema(SchemaMapper.from(schema));
+         verifyNewSchema(importSchema);
+         schema = SchemaMapper.to(importSchema);
          em.persist(schema);
       }
-      if (labels == null || labels.isNull() || labels.isMissingNode()) {
-         log.debugf("Import schema %d: no labels", schema.id);
-      }
-      else if (labels.isArray()) {
-         for (JsonNode node : labels) {
-            try {
-               LabelDAO label = LabelMapper.to(Util.OBJECT_MAPPER.treeToValue(node, Label.class));
+      if (importSchema.labels != null && !importSchema.labels.isEmpty()) {
+         for (Label l : importSchema.labels) {
+                LabelDAO label = LabelMapper.to(l);
                label.schema = schema;
                if ( label.id != null && !newSchema){
                   em.merge(label);
@@ -905,19 +891,11 @@ else if (labels.isArray()) {
                   label.schema = schema;
                   em.persist(label);
                }
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize label: " + e.getMessage());
-            }
          }
-      } else {
-         throw ServiceException.badRequest("Wrong node type for labels: " + labels.getNodeType());
-      }
-      if (transformers == null || transformers.isNull() || transformers.isMissingNode()) {
-         log.debugf("Import schema %d: no transformers", schema.id);
-      } else if (transformers.isArray()) {
-         for (JsonNode node : transformers) {
-            try {
-               TransformerDAO transformer = TransformerMapper.to(Util.OBJECT_MAPPER.treeToValue(node, Transformer.class));
+      }
+      if (importSchema.transformers != null && !importSchema.transformers.isEmpty()) {
+         for (Transformer t : importSchema.transformers) {
+            TransformerDAO transformer = TransformerMapper.to(t);
                transformer.schema = schema;
                if(transformer.id == null || transformer.id < 1) {
                   em.persist(transformer);
@@ -933,12 +911,7 @@ else if (labels.isArray()) {
                      em.persist(transformer);
                   }
                }
-            } catch (JsonProcessingException e) {
-               throw ServiceException.badRequest("Cannot deserialize transformer: " + e.getMessage());
-            }
          }
-      } else {
-         throw ServiceException.badRequest("Wrong node type for transformers: " + transformers.getNodeType());
       }
       //let's wrap flush in a try/catch, if we get any role issues at commit we can give a sane msg
       try {
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ServiceMediator.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ServiceMediator.java
index 735c95337..5514a1801 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ServiceMediator.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/ServiceMediator.java
@@ -1,11 +1,10 @@
 package io.hyperfoil.tools.horreum.svc;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.hyperfoil.tools.horreum.api.alerting.Change;
 import io.hyperfoil.tools.horreum.api.alerting.DataPoint;
 import io.hyperfoil.tools.horreum.api.data.Action;
 import io.hyperfoil.tools.horreum.api.data.Dataset;
+import io.hyperfoil.tools.horreum.api.data.TestExport;
 import io.hyperfoil.tools.horreum.api.data.Run;
 import io.hyperfoil.tools.horreum.api.data.Test;
 import io.hyperfoil.tools.horreum.api.services.ExperimentService;
@@ -186,24 +185,25 @@ void merge(ActionDAO dao) {
         actionService.merge(dao);
     }
 
-    void exportTest(ObjectNode export, int testId) {
-        export.set("alerting", alertingService.exportTest(testId));
-        export.set("actions", actionService.exportTest(testId));
-        export.set("experiments", experimentService.exportTest(testId));
-        export.set("subscriptions", subscriptionService.exportSubscriptions(testId));
+    void exportTest(TestExport test) {
+        alertingService.exportTest(test);
+        actionService.exportTest(test);
+        experimentService.exportTest(test);
+        subscriptionService.exportSubscriptions(test);
     }
 
     @Transactional
-    void importTestToAll(Integer id, JsonNode alerting, JsonNode actions, JsonNode experiments,
-                         JsonNode subscriptions, boolean forceUseTestId) {
-        if(alerting != null)
-            alertingService.importTest(id, alerting, forceUseTestId);
-        if(actions != null)
-            actionService.importTest(id, actions, forceUseTestId);
-        if(experiments != null)
-            experimentService.importTest(id, experiments, forceUseTestId);
-        if(subscriptions != null)
-            subscriptionService.importSubscriptions(id, subscriptions);
+    void importTestToAll(TestExport test) {
+        if(test.variables != null)
+            alertingService.importVariables(test);
+        if(test.missingDataRules != null)
+            alertingService.importMissingDataRules(test);
+        if(test.actions != null)
+            actionService.importTest(test);
+        if(test.experiments != null && !test.experiments.isEmpty())
+            experimentService.importTest(test);
+        if(test.subscriptions != null)
+            subscriptionService.importSubscriptions(test);
     }
 
     public void newOrUpdatedSchema(SchemaDAO schema) {
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SubscriptionServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SubscriptionServiceImpl.java
index 18eca4351..d9537ec89 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SubscriptionServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/SubscriptionServiceImpl.java
@@ -2,14 +2,11 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
+import io.hyperfoil.tools.horreum.api.data.TestExport;
 import io.hyperfoil.tools.horreum.entity.data.TestDAO;
 import jakarta.annotation.security.RolesAllowed;
 import jakarta.enterprise.context.ApplicationScoped;
@@ -19,12 +16,8 @@
 
 import io.hyperfoil.tools.horreum.api.alerting.Watch;
 import io.hyperfoil.tools.horreum.mapper.WatchMapper;
-import org.hibernate.Session;
 import org.jboss.logging.Logger;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-
 import io.hyperfoil.tools.horreum.api.internal.services.SubscriptionService;
 import io.hyperfoil.tools.horreum.entity.alerting.WatchDAO;
 import io.hyperfoil.tools.horreum.server.WithRoles;
@@ -219,21 +212,19 @@ public void onTestDelete(int testId) {
       }
    }
 
-   JsonNode exportSubscriptions(int testId) {
-      return Util.OBJECT_MAPPER.valueToTree(get(testId));
+   void exportSubscriptions(TestExport test) {
+      test.subscriptions = get(test.id);
    }
 
-   void importSubscriptions(int testId, JsonNode subscriptions) {
-      if (subscriptions.isMissingNode() || subscriptions.isNull()) {
-         log.infof("Import test %d: no subscriptions", testId);
-      } else {
-         try {
-            WatchDAO watch = WatchMapper.to(Util.OBJECT_MAPPER.treeToValue(subscriptions, Watch.class));
-            watch.test = em.getReference(TestDAO.class, testId);
-            em.merge(watch);
-         } catch (JsonProcessingException e) {
-            throw ServiceException.badRequest("Cannot deserialize subscription id '" + subscriptions.path("id").asText() + "': " + e.getMessage());
-         }
+   void importSubscriptions(TestExport test) {
+      WatchDAO watch = WatchMapper.to(test.subscriptions);
+      watch.test = em.getReference(TestDAO.class, test.id);
+      if(WatchDAO.findById(watch.id) == null) {
+         watch.id = null;
+         watch.persist();
+      }
+      else {
+         em.merge(watch);
       }
    }
 }
diff --git a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/TestServiceImpl.java b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/TestServiceImpl.java
index 31b8b1da5..a56e64552 100644
--- a/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/TestServiceImpl.java
+++ b/horreum-backend/src/main/java/io/hyperfoil/tools/horreum/svc/TestServiceImpl.java
@@ -3,10 +3,14 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.hyperfoil.tools.horreum.api.SortDirection;
 import io.hyperfoil.tools.horreum.api.data.*;
+import io.hyperfoil.tools.horreum.api.data.datastore.Datastore;
+import io.hyperfoil.tools.horreum.api.data.datastore.DatastoreType;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
 import io.hyperfoil.tools.horreum.entity.alerting.WatchDAO;
+import io.hyperfoil.tools.horreum.entity.backend.DatastoreConfigDAO;
 import io.hyperfoil.tools.horreum.entity.data.*;
 import io.hyperfoil.tools.horreum.hibernate.JsonBinaryType;
+import io.hyperfoil.tools.horreum.mapper.DatasourceMapper;
 import io.hyperfoil.tools.horreum.mapper.TestMapper;
 import io.hyperfoil.tools.horreum.mapper.TestTokenMapper;
 import io.hyperfoil.tools.horreum.api.services.TestService;
@@ -50,8 +54,6 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ArrayNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
 public class TestServiceImpl implements TestService {
@@ -586,98 +588,48 @@ public RecalculationStatus getRecalculationStatus(int testId) {
    @WithRoles
    @Transactional
    @Override
-   public String export(int testId) {
-      TestDAO test = TestDAO.findById(testId);
-      if (test == null) {
+   public TestExport export(int testId) {
+      TestDAO t = TestDAO.findById(testId);
+      if (t == null) {
          throw ServiceException.notFound("Test " + testId + " was not found");
       }
-      ObjectNode export = Util.OBJECT_MAPPER.valueToTree(TestMapper.from(test));
-      // do not export full transformers, just references - these belong to the schema
-      if (!export.path("transformers").isEmpty()) {
-         ArrayNode transformers = JsonNodeFactory.instance.arrayNode();
-         export.get("transformers").forEach(t -> {
-            ObjectNode ref = JsonNodeFactory.instance.objectNode();
-            ref.set("id", t.path("id"));
-            // only for informative purposes
-            ref.set("name", t.path("name"));
-            ref.set("schemaName", t.path("schemaName"));
-            ref.set("targetSchemaUri", t.path("targetSchemaUri"));
-            ref.set("schemaId", t.path("schemaId"));
-            transformers.add(ref);
-         });
-         export.set("transformers", transformers);
-      }
-      if (!test.tokens.isEmpty()) {
-         ArrayNode tokens = (ArrayNode) export.get("tokens");
-         for (var token : test.tokens) {
-            for (int i = 0; i < tokens.size(); ++i) {
-               ObjectNode node = (ObjectNode) tokens.get(i);
-               if (node.path("id").intValue() == token.id) {
-                  node.put("value", token.getEncryptedValue(plaintext -> {
-                     try {
-                        return encryptionManager.encrypt(plaintext);
-                     } catch (GeneralSecurityException e) {
-                        throw new RuntimeException("Cannot encrypt token value: " + e.getMessage());
-                     }
-                  }));
-               }
-            }
-         }
-      }
-      mediator.exportTest(export, testId);
-      return export.toString();
+      Test test = TestMapper.from(t);
+      if(!test.tokens.isEmpty())
+         test.tokens = null;
+      TestExport testExport = new TestExport(test);
+      //if we have non-postgres backend, we need to add the backendConfig to the export without sensitive data
+      if(t.backendConfig != null && t.backendConfig.type != DatastoreType.POSTGRES) {
+         testExport.datastore = DatasourceMapper.from(t.backendConfig);
+         testExport.datastore.pruneSecrets();
+      }
+      mediator.exportTest(testExport);
+      return testExport;
    }
 
    @RolesAllowed({Roles.ADMIN, Roles.TESTER})
    @WithRoles
    @Transactional
    @Override
-   public void importTest(String newTest) {
-      JsonNode testConfig = null;
-      try {
-         testConfig = mapper.readValue(newTest, JsonNode.class);
-      }
-      catch (JsonProcessingException e) {
-         throw ServiceException.badRequest("Request object could not be mapped to JsonNode: "+ e.getMessage());
-      }
-      if (!testConfig.isObject()) {
-         throw ServiceException.badRequest("Expected Test object as request body, got " + testConfig.getNodeType());
-      }
-      JsonNode idNode = testConfig.path("id");
-      if (!idNode.isMissingNode() && !idNode.isIntegralNumber()) {
-         throw ServiceException.badRequest("Test object has invalid id: " + idNode.asText());
-      }
-      // We need to perform a deep copy before mutating because if this
-      // transaction needs a retry we would not have the subnodes we're about to remove.
-      ObjectNode config = testConfig.deepCopy();
-      JsonNode alerting = config.remove("alerting");
-      JsonNode actions = config.remove("actions");
-      JsonNode experiments = config.remove("experiments");
-      JsonNode subscriptions = config.remove("subscriptions");
-      Test dto;
-      boolean forceUseTestId = false;
-      try {
-         dto = mapper.treeToValue(config, Test.class);
-         if (dto.tokens != null && !dto.tokens.isEmpty()) {
-            dto.tokens.forEach(token -> token.decryptValue(ciphertext -> {
-               try {
-                  return encryptionManager.decrypt(ciphertext);
-               } catch (GeneralSecurityException e) {
-                  throw new RuntimeException("Cannot decrypt token value: " + e.getMessage());
-               }
-            }));
-         }
-         if (dto.transformers != null) {
-            dto.transformers.stream().filter(t -> t.id == null || t.id <= 0).findFirst().ifPresent(transformer -> {
-               throw ServiceException.badRequest("Transformer " + transformer.name + " does not have ID set; Transformers must be imported via Schema.");
-            });
+   public void importTest(ObjectNode node) {
+      TestExport newTest = Util.OBJECT_MAPPER.convertValue(node, TestExport.class);
+      //need to add logic for datastore
+      if(newTest.datastore != null) {
+         //first check if datastore already exists
+         boolean exists = DatastoreConfigDAO.findById(newTest.datastore.id) != null;
+         DatastoreConfigDAO datastore = DatasourceMapper.to(newTest.datastore);
+         datastore.persist();
+         if(!exists) {
+            newTest.datastore.id = datastore.id;
          }
 
-         dto = add(dto);
-      } catch (JsonProcessingException e) {
-         throw ServiceException.badRequest("Failed to deserialize test: " + e.getMessage());
       }
-      mediator.importTestToAll(dto.id, alerting, actions, experiments, subscriptions, forceUseTestId);
+      Test t = add(newTest);
+
+      if(!Objects.equals(t.id, newTest.id)) {
+         newTest.id = t.id;
+         newTest.updateRefs();
+         mediator.importTestToAll(newTest);
+      }
    }
 
    protected TestDAO getTestForUpdate(int testId) {
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/AlertingServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/AlertingServiceTest.java
index 437bd7e8f..d34547861 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/AlertingServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/AlertingServiceTest.java
@@ -81,7 +81,7 @@ public class AlertingServiceTest extends BaseServiceTest {
    public void testNotifications(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      setTestVariables(test, "Value", "value");
+      setTestVariables(test, "Value", new Label("value", schema.id));
 
       BlockingQueue<DataPoint.Event> dpe = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == test.id);
       uploadRun(runWithValue(42, schema).toString(), test.name);
@@ -111,7 +111,7 @@ private String prettyPrint(Object obj) {
    public void testLogging(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      setTestVariables(test, "Value", "value");
+      setTestVariables(test, "Value", new Label("value", schema.id));
 
       // This run won't contain the 'value'
       ObjectNode runJson = JsonNodeFactory.instance.objectNode();
@@ -148,7 +148,7 @@ public void testLogging(TestInfo info) throws InterruptedException {
    public void testChangeDetection(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      ChangeDetection cd = addChangeDetectionVariable(test);
+      ChangeDetection cd = addChangeDetectionVariable(test, schema.id);
 
       BlockingQueue<DataPoint.Event> datapointQueue = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == test.id);
       BlockingQueue<Change.Event> changeQueue = eventConsumerQueue(Change.Event.class, MessageBusChannels.CHANGE_NEW, e -> e.dataset.testId == test.id);
@@ -175,7 +175,7 @@ public void testChangeDetection(TestInfo info) throws InterruptedException {
       assertEquals(run4, changeEvent1.change.dataset.runId);
 
       ((ObjectNode) cd.config).put("filter", "min");
-      setTestVariables(test, "Value", "value", cd);
+      setTestVariables(test, "Value", new Label("value", schema.id), cd);
       // After changing the variable the past datapoints and changes are removed; we need to recalculate them again
       jsonRequest().post("/api/alerting/recalculate?test=" + test.id).then().statusCode(204);
 
@@ -223,7 +223,7 @@ public void testChangeDetectionWithFingerprint(TestInfo info) throws Interrupted
       Schema schema = createExampleSchema(info);
       addLabel(schema, "config", null, new Extractor("config", "$.config", false));
 
-      addChangeDetectionVariable(test);
+      addChangeDetectionVariable(test, schema.id);
 
       BlockingQueue<DataPoint.Event> datapointQueue = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == testId);
       BlockingQueue<Change.Event> changeQueue = eventConsumerQueue(Change.Event.class, MessageBusChannels.CHANGE_NEW, e -> e.dataset.testId == testId);
@@ -266,8 +266,8 @@ public void testFingerprintLabelsChange(TestInfo info) throws Exception {
       test.fingerprintLabels = jsonArray("foo");
       test = createTest(test);
       int testId = test.id;
-      addChangeDetectionVariable(test);
       Schema schema = createExampleSchema(info);
+      addChangeDetectionVariable(test, schema.id);
       addLabel(schema, "foo", null, new Extractor("foo", "$.foo", false));
       addLabel(schema, "bar", null, new Extractor("bar", "$.bar", false));
 
@@ -311,8 +311,8 @@ public void testFingerprintFilter(TestInfo info) throws Exception {
       test.fingerprintFilter = "value => value === 'aaa'";
       test = createTest(test);
       int testId = test.id;
-      addChangeDetectionVariable(test);
       Schema schema = createExampleSchema(info);
+      addChangeDetectionVariable(test, schema.id);
       addLabel(schema, "foo", null, new Extractor("foo", "$.foo", false));
       addLabel(schema, "bar", null, new Extractor("bar", "$.bar", false));
 
@@ -561,7 +561,7 @@ public void testRecalculateDatasets(TestInfo info) throws InterruptedException {
 
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      addChangeDetectionVariable(test);
+      addChangeDetectionVariable(test, schema.id);
 
       BlockingQueue<DataPoint.Event> datapointQueue = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == test.id);
 
@@ -613,7 +613,7 @@ public void testFixedThresholds(TestInfo info) throws InterruptedException {
       config.putObject("min").put("value", 3).put("enabled", true).put("inclusive", true);
       config.putObject("max").put("value", 6).put("enabled", true).put("inclusive", false);
       rd.config = config;
-      setTestVariables(test, "Value", "value", rd);
+      setTestVariables(test, "Value", new Label("value", schema.id), rd);
 
       BlockingQueue<DataPoint.Event> datapointQueue = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == test.id);
       BlockingQueue<Change.Event> changeQueue = eventConsumerQueue(Change.Event.class, MessageBusChannels.CHANGE_NEW, e -> e.dataset.testId == test.id);
@@ -644,7 +644,7 @@ public void testCustomTimeline(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
       addLabel(schema, "timestamp", null, new Extractor("ts", "$.timestamp", false));
-      addChangeDetectionVariable(test);
+      addChangeDetectionVariable(test, schema.id);
       setChangeDetectionTimeline(test, Collections.singletonList("timestamp"), null);
 
       BlockingQueue<DataPoint.Event> datapointQueue = eventConsumerQueue(DataPoint.Event.class, MessageBusChannels.DATAPOINT_NEW, e -> e.testId == test.id);
@@ -693,7 +693,7 @@ private void setChangeDetectionTimeline(Test test, List<String> labels, String f
    public void testLabelsChange(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      addChangeDetectionVariable(test);
+      addChangeDetectionVariable(test, schema.id);
       LabelDAO l = LabelDAO.find("name", "value").firstResult();
       Label label = LabelMapper.from(l);
 
@@ -720,7 +720,7 @@ public void testLabelsChange(TestInfo info) throws InterruptedException {
    public void testRandomOrder(TestInfo info) throws InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      addChangeDetectionVariable(test, 0.1, 1);
+      addChangeDetectionVariable(test, 0.1, 1, schema.id);
       addLabel(schema, "timestamp", null, new Extractor("ts", "$.timestamp", false));
       setChangeDetectionTimeline(test, Collections.singletonList("timestamp"), null);
 
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/BaseServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/BaseServiceTest.java
index e893b3c70..09a5e7370 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/BaseServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/BaseServiceTest.java
@@ -67,7 +67,6 @@
 import io.hyperfoil.tools.horreum.experiment.RelativeDifferenceExperimentModel;
 import io.hyperfoil.tools.horreum.server.CloseMe;
 import io.hyperfoil.tools.horreum.server.RoleManager;
-import io.hyperfoil.tools.horreum.test.TestUtil;
 import io.restassured.RestAssured;
 import io.restassured.response.Response;
 import io.restassured.specification.RequestSpecification;
@@ -82,6 +81,8 @@ public class BaseServiceTest {
    private static String TESTER_TOKEN;
    private static String ADMIN_TOKEN;
 
+   int lastAddedLabelId;
+
    protected final Logger log = Logger.getLogger(getClass());
 
    @Inject
@@ -480,7 +481,8 @@ protected String uriForTest(TestInfo info, String suffix) {
    }
 
    protected int addLabel(Schema schema, String name, String function, Extractor... extractors) {
-      return postLabel(schema, name, function, null, extractors);
+      lastAddedLabelId = postLabel(schema, name, function, null, extractors);
+      return lastAddedLabelId;
    }
 
    protected int updateLabel(Schema schema, int labelId, String name, String function, Extractor... extractors) {
@@ -507,25 +509,21 @@ protected void deleteLabel(Schema schema, int labelId) {
       jsonRequest().delete("/api/schema/" + schema.id + "/labels/" + labelId).then().statusCode(204);
    }
 
-   protected void setTestVariables(Test test, String name, String label, ChangeDetection... rds) {
-      setTestVariables(test, name, Collections.singletonList(label), rds);
+   protected void setTestVariables(Test test, String name, Label label, ChangeDetection... rds) {
+      label.id = lastAddedLabelId;
+      setTestVariables(test, name, Collections.singletonList(label.name), rds);
    }
 
    protected void setTestVariables(Test test, String name, List<String> labels, ChangeDetection... rds) {
-      ArrayNode variables = JsonNodeFactory.instance.arrayNode();
-      ObjectNode variable = JsonNodeFactory.instance.objectNode();
-      variable.put("testid", test.id);
-      variable.put("name", name);
-      variable.set("labels", labels.stream().reduce(JsonNodeFactory.instance.arrayNode(), ArrayNode::add, ArrayNode::addAll));
-      if (rds.length > 0) {
-         ArrayNode rdsArray = JsonNodeFactory.instance.arrayNode();
-         for (ChangeDetection rd : rds) {
-            rdsArray.add(JsonNodeFactory.instance.objectNode().put("model", rd.model).set("config", rd.config));
-         }
-         variable.set("changeDetection", rdsArray);
-      }
+      List<Variable> variables = new ArrayList<>();
+      Variable variable = new Variable();
+      variable.testId = test.id;
+      variable.name = name;
+      variable.labels = labels;
+      variable.changeDetection = Arrays.stream(rds).collect(Collectors.toSet());
+
       variables.add(variable);
-      jsonRequest().body(variables.toString()).post("/api/alerting/variables?test=" + test.id).then().statusCode(204);
+      jsonRequest().body(variables).post("/api/alerting/variables?test=" + test.id).then().statusCode(204);
    }
 
    protected void updateVariables(Integer testId, List<Variable> variables) {
@@ -754,15 +752,15 @@ protected Response addGlobalAction(MessageBusChannels event, String url) {
             .header(HttpHeaders.CONTENT_TYPE, "application/json").body(action).post("/api/action");
    }
 
-   protected ChangeDetection addChangeDetectionVariable(Test test) {
-      return addChangeDetectionVariable(test, 0.1, 2);
+   protected ChangeDetection addChangeDetectionVariable(Test test, int schemaId) {
+      return addChangeDetectionVariable(test, 0.1, 2, schemaId);
    }
 
-   protected ChangeDetection addChangeDetectionVariable(Test test, double threshold, int window) {
+   protected ChangeDetection addChangeDetectionVariable(Test test, double threshold, int window, int schemaId) {
       ChangeDetection cd = new ChangeDetection();
       cd.model = RelativeDifferenceChangeDetectionModel.NAME;
       cd.config = JsonNodeFactory.instance.objectNode().put("threshold", threshold).put("minPrevious", window).put("window", window).put("filter", "mean");
-      setTestVariables(test, "Value", "value", cd);
+      setTestVariables(test, "Value", new Label("value", schemaId), cd);
       return cd;
    }
 
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/LogServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/LogServiceTest.java
index e66d00ebf..54fb921da 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/LogServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/LogServiceTest.java
@@ -6,6 +6,7 @@
 import io.hyperfoil.tools.horreum.api.alerting.DatasetLog;
 import io.hyperfoil.tools.horreum.api.alerting.TransformationLog;
 import io.hyperfoil.tools.horreum.api.data.ActionLog;
+import io.hyperfoil.tools.horreum.api.data.Label;
 import io.hyperfoil.tools.horreum.api.data.Schema;
 import io.hyperfoil.tools.horreum.api.data.Test;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
@@ -37,7 +38,7 @@ public class LogServiceTest extends BaseServiceTest {
     public void testLogs(TestInfo info) throws JsonProcessingException, InterruptedException {
       Test test = createTest(createExampleTest(getTestName(info)));
       Schema schema = createExampleSchema(info);
-      setTestVariables(test, "Value", "value");
+      setTestVariables(test, "Value", new Label("value", schema.id));
 
       // This run won't contain the 'value'
       ObjectNode runJson = JsonNodeFactory.instance.objectNode();
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/RunServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/RunServiceTest.java
index d7b827ad4..096acc9ab 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/RunServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/RunServiceTest.java
@@ -27,6 +27,7 @@
 import io.hyperfoil.tools.horreum.api.services.RunService;
 import io.hyperfoil.tools.horreum.bus.MessageBusChannels;
 import io.hyperfoil.tools.horreum.mapper.DatasetMapper;
+import io.restassured.response.Response;
 import jakarta.ws.rs.core.HttpHeaders;
 
 import io.hyperfoil.tools.horreum.test.HorreumTestProfile;
@@ -122,7 +123,7 @@ public void testTransformationWithoutSchemaInUpload(TestInfo info) throws Interr
       Test test = createTest(createExampleTest(getTestName(info)));
       BlockingQueue<Dataset.EventNew> dataSetQueue = eventConsumerQueue(Dataset.EventNew.class, MessageBusChannels.DATASET_NEW, e -> e.testId == test.id);
 
-      setTestVariables(test, "Value", "value");
+      setTestVariables(test, "Value", new Label("value", 1));
 
       uploadRun( "{ \"foo\":\"bar\"}", test.name);
 
@@ -860,7 +861,10 @@ public void runExperiment() throws InterruptedException {
          variable.testId = test.id;
          variable.name = "throughput";
          variable.order = 0;
-         variable.labels = mapper.readTree("[ \"throughput\" ]");
+         variable.labels = new ArrayList<>();
+         Label l = new Label();
+         l.name = "throughput";
+         variable.labels.add(l.name);
          ChangeDetection changeDetection = new ChangeDetection();
          changeDetection.model = "relativeDifference";
 
@@ -895,12 +899,13 @@ public void runExperiment() throws InterruptedException {
 
          ExperimentComparison experimentComparison = new ExperimentComparison();
          experimentComparison.model = "relativeDifference";
+         experimentComparison.variableName = variableList.get(0).name; //should only contain one variable
          experimentComparison.variableId = variableList.get(0).id; //should only contain one variable
-         experimentComparison.config = mapper.readValue("{" +
+         experimentComparison.config = (ObjectNode) mapper.readTree("{" +
                  "          \"maxBaselineDatasets\": 0," +
                  "          \"threshold\": 0.1," +
                  "          \"greaterBetter\": true" +
-                 "        }", ObjectNode.class);
+                 "        }");
 
 
          experimentProfile.comparisons = Collections.singletonList(experimentComparison);
@@ -942,6 +947,16 @@ public void runExperiment() throws InterruptedException {
                  .then()
                  .statusCode(204);
 
+         Response response = jsonRequest().get("/api/test/" + test.id + "/export").then()
+                 .statusCode(200).extract().response();
+
+         String export = response.asString();
+
+         TestExport testExport = response.as(TestExport.class);
+
+            assertNotNull(testExport);
+
+
       }
       catch (Exception e) {
          e.printStackTrace();
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/SchemaServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/SchemaServiceTest.java
index adea56738..fb6a378ce 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/SchemaServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/SchemaServiceTest.java
@@ -204,6 +204,8 @@ public void testImportWithTransformers() throws JsonProcessingException {
       assertNotNull(s);
       assertEquals(30, LabelDAO.find("schema.id", s.id).count());
       assertEquals(1, TransformerDAO.find("schema.id", s.id).count());
+      TransformerDAO t = TransformerDAO.find("schema.id", s.id).firstResult();
+      assertEquals(12, t.extractors.size());
 
       String s2 = readFile(p.resolve("quarkus_sb_schema_empty.json").toFile());
       // this should fail since the uri is identical to an already imported test
diff --git a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/TestServiceTest.java b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/TestServiceTest.java
index 8d586369a..a10312032 100644
--- a/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/TestServiceTest.java
+++ b/horreum-backend/src/test/java/io/hyperfoil/tools/horreum/svc/TestServiceTest.java
@@ -24,6 +24,7 @@
 import io.hyperfoil.tools.horreum.entity.alerting.*;
 import io.hyperfoil.tools.horreum.entity.data.*;
 import io.restassured.common.mapper.TypeRef;
+import io.restassured.response.Response;
 import org.hibernate.query.NativeQuery;
 import org.junit.jupiter.api.TestInfo;
 
@@ -236,7 +237,7 @@ private void testImportExport(boolean wipe) throws InterruptedException {
       addTestGithubIssueCommentAction(test, MessageBusChannels.EXPERIMENT_RESULT_NEW,
             ExperimentResultToMarkdown.NAME, "hyperfoil", "horreum", "123", "super-secret-github-token");
 
-      addChangeDetectionVariable(test);
+      addChangeDetectionVariable(test, schema.id);
       addMissingDataRule(test, "Let me know", JsonNodeFactory.instance.arrayNode().add("foo"), null,
             (int) TimeUnit.DAYS.toMillis(1));
 
@@ -245,8 +246,15 @@ private void testImportExport(boolean wipe) throws InterruptedException {
 
       HashMap<String, List<JsonNode>> db = dumpDatabaseContents();
 
-      String testJson = jsonRequest().get("/api/test/" + test.id + "/export").then()
-            .statusCode(200).extract().body().asString();
+      Response response = jsonRequest().get("/api/test/" + test.id + "/export").then()
+            .statusCode(200).extract().response();
+
+      String export = response.asString();
+
+      TestExport testExport = response.as(TestExport.class);
+      assertEquals(testExport.id, test.id);
+      assertEquals(testExport.variables.size(), 1);
+
 
       if (wipe) {
          BlockingQueue<Test> events = eventConsumerQueue(Test.class, MessageBusChannels.TEST_DELETED, t -> (t.id == test.id));
@@ -269,7 +277,7 @@ private void testImportExport(boolean wipe) throws InterruptedException {
 
       //wipeing and inserting with the same ids just results in too much foobar
       if(!wipe) {
-         jsonRequest().body(testJson).post("/api/test/import").then().statusCode(204);
+         jsonRequest().body(testExport).post("/api/test/import").then().statusCode(204);
          //if we wipe, we actually import a new test and there is no use validating the db
          validateDatabaseContents(db);
          //clean up after us
@@ -293,6 +301,10 @@ public void testImportWithTransformers() throws InterruptedException {
       List<SchemaService.SchemaDescriptor> descriptors = jsonRequest().get("/api/schema/descriptors")
               .then().statusCode(200).extract().body().as(new TypeRef<>() {});
       assertEquals("quarkus-sb-compare", descriptors.get(0).name);
+
+      List<ExperimentProfileDAO> experiments = ExperimentProfileDAO.list("test.id", test.id);
+      assertEquals(1, experiments.size());
+      assertNotNull( experiments.get(0).comparisons.get(0).variable);
    }
 
    @org.junit.jupiter.api.Test
diff --git a/horreum-integration-tests/src/test/java/io/hyperfoil/tools/horreum/it/HorreumClientIT.java b/horreum-integration-tests/src/test/java/io/hyperfoil/tools/horreum/it/HorreumClientIT.java
index 282a1ccb8..169afece8 100644
--- a/horreum-integration-tests/src/test/java/io/hyperfoil/tools/horreum/it/HorreumClientIT.java
+++ b/horreum-integration-tests/src/test/java/io/hyperfoil/tools/horreum/it/HorreumClientIT.java
@@ -190,7 +190,7 @@ public void runExperiment() {
             variable.testId = dummyTest.id;
             variable.name = "throughput";
             variable.order = 0;
-            variable.labels = mapper.readTree("[ \"throughput\" ]");
+            variable.labels = Collections.singletonList("throughput");
             ChangeDetection changeDetection = new ChangeDetection();
             changeDetection.model = "relativeDifference";
 
diff --git a/horreum-web/src/components/ExportImport.tsx b/horreum-web/src/components/ExportImport.tsx
index 319c909f1..842126878 100644
--- a/horreum-web/src/components/ExportImport.tsx
+++ b/horreum-web/src/components/ExportImport.tsx
@@ -8,18 +8,19 @@ import { Button, FileUpload, Flex, FlexItem, Form, FormGroup, Spinner,
 import ExportButton from "./ExportButton"
 import {AppContext} from "../context/appContext";
 import {AppContextType} from "../context/@types/appContextTypes";
+import { SchemaExport, TestExport } from "../generated";
 
 type ExportImportProps = {
     name: string
     export(): Promise<any>
-    import(cfg: string): Promise<void>
-    validate(cfg: string): Promise<boolean>
+    import(cfg: SchemaExport | TestExport): Promise<void>
+    validate(cfg: SchemaExport | TestExport): Promise<boolean>
 }
 
 export default function ExportImport(props: ExportImportProps) {
     const [uploadName, setUploadName] = useState<string>()
     const [loading, setLoading] = useState(false)
-    const [uploadContent, setUploadContent] = useState<string>()
+    const [uploadContent, setUploadContent] = useState<SchemaExport | TestExport>()
     const [uploading, setUploading] = useState(false)
     const [parseError, setParseError] = useState<any>(undefined)
     const { alerting } = useContext(AppContext) as AppContextType;
diff --git a/horreum-web/src/components/ImportButton.tsx b/horreum-web/src/components/ImportButton.tsx
index 9bc79fa97..47e5a82c4 100644
--- a/horreum-web/src/components/ImportButton.tsx
+++ b/horreum-web/src/components/ImportButton.tsx
@@ -3,11 +3,12 @@ import {useContext, useState} from "react"
 import { Bullseye, Button, FileUpload, Modal, Spinner } from "@patternfly/react-core"
 import {AppContext} from "../context/appContext";
 import {AppContextType} from "../context/@types/appContextTypes";
+import { SchemaExport, TestExport } from "../generated";
 
 type ImportProps = {
     label?: string
     onLoad(config: Record<string, unknown>): Promise<any> | any
-    onImport(config: string): Promise<unknown>
+    onImport(config: SchemaExport | TestExport): Promise<unknown>
     onImported(): void
 }
 
@@ -18,7 +19,7 @@ export default function ImportButton({label, onLoad, onImport, onImported}: Impo
     const [filename, setFilename] = useState<string>()
     const [loading, setLoading] = useState(false)
     const [checking, setChecking] = useState(false)
-    const [config, setConfig] = useState<string>()
+    const [config, setConfig] = useState<SchemaExport | TestExport>()
     const [uploading, setUploading] = useState(false)
     const [parseError, setParseError] = useState<any>()
     const [overridden, setOverridden] = useState<any>()
diff --git a/infra-legacy/example-data/quarkus_sb_test.json b/infra-legacy/example-data/quarkus_sb_test.json
index 3b9001d39..5f420e98e 100644
--- a/infra-legacy/example-data/quarkus_sb_test.json
+++ b/infra-legacy/example-data/quarkus_sb_test.json
@@ -21,131 +21,129 @@
     }
   ],
   "notificationsEnabled": true,
-  "alerting": {
-    "variables": [
-      {
-        "id": 3523654,
-        "testId": 113,
-        "name": "Average Time to First Request",
-        "group": null,
-        "order": 0,
-        "labels": ["avTimeToFirstRequest"],
-        "changeDetection": [
-          {
-            "id": 3523656,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 1,
-              "threshold": 0.2,
-              "minPrevious": 5
-            }
-          },
-          {
-            "id": 3523655,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 5,
-              "threshold": 0.1,
-              "minPrevious": 5
-            }
+  "variables": [
+    {
+      "id": 3523654,
+      "testId": 113,
+      "name": "Average Time to First Request",
+      "group": null,
+      "order": 0,
+      "labels": ["avTimeToFirstRequest"],
+      "changeDetection": [
+        {
+          "id": 3523656,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 1,
+            "threshold": 0.2,
+            "minPrevious": 5
           }
-        ]
-      },
-      {
-        "id": 3525316,
-        "testId": 113,
-        "name": "Average Throughput",
-        "group": null,
-        "order": 1,
-        "labels": ["avThroughput"],
-        "changeDetection": [
-          {
-            "id": 3525317,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 1,
-              "threshold": 0.2,
-              "minPrevious": 5
-            }
-          },
-          {
-            "id": 3525318,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 5,
-              "threshold": 0.1,
-              "minPrevious": 5
-            }
+        },
+        {
+          "id": 3523655,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 5,
+            "threshold": 0.1,
+            "minPrevious": 5
           }
-        ]
-      },
-      {
-        "id": 3525319,
-        "testId": 113,
-        "name": "Averge Build Time",
-        "group": null,
-        "order": 2,
-        "labels": ["avBuildTime"],
-        "changeDetection": [
-          {
-            "id": 3525320,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 5,
-              "threshold": 0.1,
-              "minPrevious": 5
-            }
-          },
-          {
-            "id": 3525321,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 1,
-              "threshold": 0.2,
-              "minPrevious": 5
-            }
+        }
+      ]
+    },
+    {
+      "id": 3525316,
+      "testId": 113,
+      "name": "Average Throughput",
+      "group": null,
+      "order": 1,
+      "labels": ["avThroughput"],
+      "changeDetection": [
+        {
+          "id": 3525317,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 1,
+            "threshold": 0.2,
+            "minPrevious": 5
           }
-        ]
-      },
-      {
-        "id": 3525322,
-        "testId": 113,
-        "name": "Averge Time to First Request",
-        "group": null,
-        "order": 3,
-        "labels": ["avTimeToFirstRequest"],
-        "changeDetection": [
-          {
-            "id": 3525323,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 1,
-              "threshold": 0.2,
-              "minPrevious": 5
-            }
-          },
-          {
-            "id": 3525324,
-            "model": "relativeDifference",
-            "config": {
-              "filter": "mean",
-              "window": 5,
-              "threshold": 0.1,
-              "minPrevious": 5
-            }
+        },
+        {
+          "id": 3525318,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 5,
+            "threshold": 0.1,
+            "minPrevious": 5
+          }
+        }
+      ]
+    },
+    {
+      "id": 3525319,
+      "testId": 113,
+      "name": "Averge Build Time",
+      "group": null,
+      "order": 2,
+      "labels": ["avBuildTime"],
+      "changeDetection": [
+        {
+          "id": 3525320,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 5,
+            "threshold": 0.1,
+            "minPrevious": 5
           }
-        ]
-      }
-    ],
-    "missingDataRules": []
-  },
+        },
+        {
+          "id": 3525321,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 1,
+            "threshold": 0.2,
+            "minPrevious": 5
+          }
+        }
+      ]
+    },
+    {
+      "id": 3525322,
+      "testId": 113,
+      "name": "Averge Time to First Request",
+      "group": null,
+      "order": 3,
+      "labels": ["avTimeToFirstRequest"],
+      "changeDetection": [
+        {
+          "id": 3525323,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 1,
+            "threshold": 0.2,
+            "minPrevious": 5
+          }
+        },
+        {
+          "id": 3525324,
+          "model": "relativeDifference",
+          "config": {
+            "filter": "mean",
+            "window": 5,
+            "threshold": 0.1,
+            "minPrevious": 5
+          }
+        }
+      ]
+    }
+  ],
+  "missingDataRules": [],
   "actions": [],
   "experiments": [
     {